@fuel-ts/account 0.0.0-pr-1788-20240222094224 → 0.75.0

package/dist/test-utils.global.js

@@ -33066,7 +33066,7 @@ spurious results.`);
     return {
       FORC: "0.50.0",
       FUEL_CORE: "0.22.1",
-      FUELS: "0.74.0"
+      FUELS: "0.75.0"
     };
   }
   function parseVersion(version2) {
@@ -33132,6 +33132,7 @@ spurious results.`);
     ErrorCode2["CODER_NOT_FOUND"] = "coder-not-found";
     ErrorCode2["INVALID_DATA"] = "invalid-data";
     ErrorCode2["FUNCTION_NOT_FOUND"] = "function-not-found";
+    ErrorCode2["UNSUPPORTED_ENCODING_VERSION"] = "unsupported-encoding-version";
     ErrorCode2["INVALID_BECH32_ADDRESS"] = "invalid-bech32-address";
     ErrorCode2["INVALID_EVM_ADDRESS"] = "invalid-evm-address";
     ErrorCode2["INVALID_B256_ADDRESS"] = "invalid-b256-address";
@@ -36160,16 +36161,28 @@ spurious results.`);
       this.encodedLength = encodedLength;
     }
   };
+  var U8_CODER_TYPE = "u8";
+  var U16_CODER_TYPE = "u16";
+  var U32_CODER_TYPE = "u32";
+  var U64_CODER_TYPE = "u64";
+  var RAW_PTR_CODER_TYPE = "raw untyped ptr";
+  var RAW_SLICE_CODER_TYPE = "raw untyped slice";
+  var BOOL_CODER_TYPE = "bool";
+  var B256_CODER_TYPE = "b256";
+  var B512_CODER_TYPE = "struct B512";
   var OPTION_CODER_TYPE = "enum Option";
   var VEC_CODER_TYPE = "struct Vec";
   var BYTES_CODER_TYPE = "struct Bytes";
   var STD_STRING_CODER_TYPE = "struct String";
+  var STR_SLICE_CODER_TYPE = "str";
   var stringRegEx = /str\[(?<length>[0-9]+)\]/;
   var arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
   var structRegEx = /^struct (?<name>\w+)$/;
   var enumRegEx = /^enum (?<name>\w+)$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
   var genericRegEx = /^generic (?<name>\w+)$/;
+  var ENCODING_V0 = "0";
+  var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
   var ASSET_ID_LEN = BYTES_32;
@@ -36910,6 +36923,246 @@ spurious results.`);
       ];
     }
   };
+  var ResolvedAbiType = class {
+    abi;
+    name;
+    type;
+    originalTypeArguments;
+    components;
+    constructor(abi, argument) {
+      this.abi = abi;
+      const type3 = findOrThrow(
+        abi.types,
+        (t) => t.typeId === argument.type,
+        () => {
+          throw new FuelError(
+            ErrorCode.TYPE_NOT_FOUND,
+            `Type does not exist in the provided abi: ${JSON.stringify({
+              argument,
+              abi: this.abi
+            })}`
+          );
+        }
+      );
+      this.name = argument.name;
+      this.type = type3.type;
+      this.originalTypeArguments = argument.typeArguments;
+      this.components = ResolvedAbiType.getResolvedGenericComponents(
+        abi,
+        argument,
+        type3.components,
+        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
+      );
+    }
+    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
+      if (components === null) {
+        return null;
+      }
+      if (typeParameters === null || typeParameters.length === 0) {
+        return components.map((c) => new ResolvedAbiType(abi, c));
+      }
+      const typeParametersAndArgsMap = typeParameters.reduce(
+        (obj, typeParameter, typeParameterIndex) => {
+          const o = { ...obj };
+          o[typeParameter] = structuredClone(
+            arg.typeArguments?.[typeParameterIndex]
+          );
+          return o;
+        },
+        {}
+      );
+      const resolvedComponents = this.resolveGenericArgTypes(
+        abi,
+        components,
+        typeParametersAndArgsMap
+      );
+      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
+    }
+    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
+      return args.map((arg) => {
+        if (typeParametersAndArgsMap[arg.type] !== void 0) {
+          return {
+            ...typeParametersAndArgsMap[arg.type],
+            name: arg.name
+          };
+        }
+        if (arg.typeArguments) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: this.resolveGenericArgTypes(
+              abi,
+              arg.typeArguments,
+              typeParametersAndArgsMap
+            )
+          };
+        }
+        const argType = findOrThrow(abi.types, (t) => t.typeId === arg.type);
+        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
+        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
+          };
+        }
+        return arg;
+      });
+    }
+    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
+      if (!Array.isArray(args)) {
+        return null;
+      }
+      const implicitGenericParameters = implicitGenericParametersParam ?? [];
+      args.forEach((a) => {
+        const argType = findOrThrow(abi.types, (t) => t.typeId === a.type);
+        if (genericRegEx.test(argType.type)) {
+          implicitGenericParameters.push(argType.typeId);
+          return;
+        }
+        if (!Array.isArray(a.typeArguments)) {
+          return;
+        }
+        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
+      });
+      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
+    }
+    getSignature() {
+      const prefix = this.getArgSignaturePrefix();
+      const content = this.getArgSignatureContent();
+      return `${prefix}${content}`;
+    }
+    getArgSignaturePrefix() {
+      const structMatch = structRegEx.test(this.type);
+      if (structMatch) {
+        return "s";
+      }
+      const arrayMatch = arrayRegEx.test(this.type);
+      if (arrayMatch) {
+        return "a";
+      }
+      const enumMatch = enumRegEx.test(this.type);
+      if (enumMatch) {
+        return "e";
+      }
+      return "";
+    }
+    getArgSignatureContent() {
+      if (this.type === "raw untyped ptr") {
+        return "rawptr";
+      }
+      if (this.type === "raw untyped slice") {
+        return "rawslice";
+      }
+      const strMatch = stringRegEx.exec(this.type)?.groups;
+      if (strMatch) {
+        return `str[${strMatch.length}]`;
+      }
+      if (this.components === null) {
+        return this.type;
+      }
+      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
+      if (arrayMatch) {
+        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
+      }
+      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
+      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
+      return `${typeArgumentsSignature}${componentsSignature}`;
+    }
+  };
+  function getCoders(components, options) {
+    const { getCoder: getCoder3 } = options;
+    return components.reduce((obj, component) => {
+      const o = obj;
+      o[component.name] = getCoder3(component, options);
+      return o;
+    }, {});
+  }
+  var getCoder = (resolvedAbiType, options) => {
+    switch (resolvedAbiType.type) {
+      case U8_CODER_TYPE:
+      case U16_CODER_TYPE:
+      case U32_CODER_TYPE:
+        return new NumberCoder(resolvedAbiType.type, options);
+      case U64_CODER_TYPE:
+      case RAW_PTR_CODER_TYPE:
+        return new U64Coder();
+      case RAW_SLICE_CODER_TYPE:
+        return new RawSliceCoder();
+      case BOOL_CODER_TYPE:
+        return new BooleanCoder(options);
+      case B256_CODER_TYPE:
+        return new B256Coder();
+      case B512_CODER_TYPE:
+        return new B512Coder();
+      case BYTES_CODER_TYPE:
+        return new ByteCoder();
+      case STD_STRING_CODER_TYPE:
+        return new StdStringCoder();
+      default:
+        break;
+    }
+    const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
+    if (stringMatch) {
+      const length = parseInt(stringMatch.length, 10);
+      return new StringCoder(length);
+    }
+    const components = resolvedAbiType.components;
+    const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
+    if (arrayMatch) {
+      const length = parseInt(arrayMatch.length, 10);
+      const arg = components[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Array type is missing an item of 'component'.`
+        );
+      }
+      const arrayElementCoder = getCoder(arg, { isSmallBytes: true });
+      return new ArrayCoder(arrayElementCoder, length);
+    }
+    if (resolvedAbiType.type === VEC_CODER_TYPE) {
+      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Vec type is missing the 'type argument'.`
+        );
+      }
+      const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
+      const itemCoder = getCoder(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
+      return new VecCoder(itemCoder);
+    }
+    const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
+    if (structMatch) {
+      const coders = getCoders(components, { isRightPadded: true, getCoder });
+      return new StructCoder(structMatch.name, coders);
+    }
+    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
+    if (enumMatch) {
+      const coders = getCoders(components, { getCoder });
+      const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
+      if (isOptionEnum) {
+        return new OptionCoder(enumMatch.name, coders);
+      }
+      return new EnumCoder(enumMatch.name, coders);
+    }
+    const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
+    if (tupleMatch) {
+      const coders = components.map(
+        (component) => getCoder(component, { isRightPadded: true, encoding: ENCODING_V0 })
+      );
+      return new TupleCoder(coders);
+    }
+    if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
+      throw new FuelError(
+        ErrorCode.INVALID_DATA,
+        "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
+      );
+    }
+    throw new FuelError(
+      ErrorCode.CODER_NOT_FOUND,
+      `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
+    );
+  };
   var BooleanCoder2 = class extends Coder {
     constructor() {
       super("boolean", "boolean", 1);
@@ -36937,10 +37190,15 @@ spurious results.`);
   };
   var ByteCoder2 = class extends Coder {
     constructor() {
-      super("struct", "struct Bytes", 1);
+      super("struct", "struct Bytes", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Bytes encode unsupported in v1`);
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const bytes4 = new Uint8Array(value);
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < WORD_SIZE) {
@@ -36949,12 +37207,11 @@ spurious results.`);
       const offsetAndLength = offset + WORD_SIZE;
       const lengthBytes = data.slice(offset, offsetAndLength);
       const length = bn(new U64Coder().decode(lengthBytes, 0)[0]).toNumber();
-      const dataLength2 = length * this.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
       if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
       }
-      return [dataBytes, offset + dataLength2];
+      return [dataBytes, offsetAndLength + length];
     }
   };
   __publicField3(ByteCoder2, "memorySize", 1);
@@ -36979,8 +37236,28 @@ spurious results.`);
       this.#caseIndexCoder = caseIndexCoder;
       this.#encodedValueSize = encodedValueSize;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Enum encode unsupported in v1`);
+    #encodeNativeEnum(value) {
+      const valueCoder = this.coders[value];
+      const encodedValue = valueCoder.encode([]);
+      const caseIndex = Object.keys(this.coders).indexOf(value);
+      const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
+      return concat([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
+    }
+    encode(value) {
+      if (typeof value === "string" && this.coders[value]) {
+        return this.#encodeNativeEnum(value);
+      }
+      const [caseKey, ...empty] = Object.keys(value);
+      if (!caseKey) {
+        throw new FuelError(ErrorCode.INVALID_DECODE_VALUE, "A field for the case must be provided.");
+      }
+      if (empty.length !== 0) {
+        throw new FuelError(ErrorCode.INVALID_DECODE_VALUE, "Only one field must be provided.");
+      }
+      const valueCoder = this.coders[caseKey];
+      const caseIndex = Object.keys(this.coders).indexOf(caseKey);
+      const encodedValue = valueCoder.encode(value[caseKey]);
+      return new Uint8Array([...this.#caseIndexCoder.encode(caseIndex), ...encodedValue]);
     }
     #decodeNativeEnum(caseKey, newOffset) {
       return [caseKey, newOffset];
@@ -37055,8 +37332,14 @@ spurious results.`);
     constructor() {
       super("raw untyped slice", "raw untyped slice", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Raw slice encode unsupported in v1`);
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const internalCoder = new ArrayCoder(new NumberCoder2("u8"), value.length);
+      const bytes4 = internalCoder.encode(value);
+      const lengthBytes = new U64Coder().encode(bytes4.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -37078,8 +37361,10 @@ spurious results.`);
     constructor() {
       super("struct", "struct String", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `StdString encode unsupported in v1`);
+    encode(value) {
+      const bytes4 = toUtf8Bytes(value);
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -37129,8 +37414,20 @@ spurious results.`);
       this.name = name;
       this.coders = coders;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Struct encode unsupported in v1`);
+    encode(value) {
+      return concatBytes2(
+        Object.keys(this.coders).map((fieldName) => {
+          const fieldCoder = this.coders[fieldName];
+          const fieldValue = value[fieldName];
+          if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+            throw new FuelError(
+              ErrorCode.ENCODE_ERROR,
+              `Invalid ${this.type}. Field "${fieldName}" not present.`
+            );
+          }
+          return fieldCoder.encode(fieldValue);
+        })
+      );
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -37158,7 +37455,7 @@ spurious results.`);
       if (this.coders.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Tuple encode unsupported in v1`);
+      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -37179,8 +37476,13 @@ spurious results.`);
       super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
       this.coder = coder;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Vec encode unsupported in v1`);
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const bytes4 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes4)]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -37202,157 +37504,112 @@ spurious results.`);
       ];
     }
   };
-  var ResolvedAbiType = class {
-    abi;
-    name;
-    type;
-    originalTypeArguments;
-    components;
-    constructor(abi, argument) {
-      this.abi = abi;
-      const type3 = findOrThrow(
-        abi.types,
-        (t) => t.typeId === argument.type,
-        () => {
-          throw new FuelError(
-            ErrorCode.TYPE_NOT_FOUND,
-            `Type does not exist in the provided abi: ${JSON.stringify({
-              argument,
-              abi: this.abi
-            })}`
-          );
-        }
-      );
-      this.name = argument.name;
-      this.type = type3.type;
-      this.originalTypeArguments = argument.typeArguments;
-      this.components = ResolvedAbiType.getResolvedGenericComponents(
-        abi,
-        argument,
-        type3.components,
-        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
-      );
+  var getCoder2 = (resolvedAbiType, _options) => {
+    switch (resolvedAbiType.type) {
+      case U8_CODER_TYPE:
+      case U16_CODER_TYPE:
+      case U32_CODER_TYPE:
+        return new NumberCoder2(resolvedAbiType.type);
+      case U64_CODER_TYPE:
+      case RAW_PTR_CODER_TYPE:
+        return new U64Coder();
+      case RAW_SLICE_CODER_TYPE:
+        return new RawSliceCoder2();
+      case BOOL_CODER_TYPE:
+        return new BooleanCoder2();
+      case B256_CODER_TYPE:
+        return new B256Coder();
+      case B512_CODER_TYPE:
+        return new B512Coder();
+      case BYTES_CODER_TYPE:
+        return new ByteCoder2();
+      case STD_STRING_CODER_TYPE:
+        return new StdStringCoder2();
+      default:
+        break;
     }
-    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
-      if (components === null) {
-        return null;
-      }
-      if (typeParameters === null || typeParameters.length === 0) {
-        return components.map((c) => new ResolvedAbiType(abi, c));
+    const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
+    if (stringMatch) {
+      const length = parseInt(stringMatch.length, 10);
+      return new StringCoder2(length);
+    }
+    const components = resolvedAbiType.components;
+    const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
+    if (arrayMatch) {
+      const length = parseInt(arrayMatch.length, 10);
+      const arg = components[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Array type is missing an item of 'component'.`
+        );
       }
-      const typeParametersAndArgsMap = typeParameters.reduce(
-        (obj, typeParameter, typeParameterIndex) => {
-          const o = { ...obj };
-          o[typeParameter] = structuredClone(
-            arg.typeArguments?.[typeParameterIndex]
-          );
-          return o;
-        },
-        {}
-      );
-      const resolvedComponents = this.resolveGenericArgTypes(
-        abi,
-        components,
-        typeParametersAndArgsMap
-      );
-      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
+      const arrayElementCoder = getCoder2(arg, { isSmallBytes: true });
+      return new ArrayCoder(arrayElementCoder, length);
     }
-    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
-      return args.map((arg) => {
-        if (typeParametersAndArgsMap[arg.type] !== void 0) {
-          return {
-            ...typeParametersAndArgsMap[arg.type],
-            name: arg.name
-          };
-        }
-        if (arg.typeArguments) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: this.resolveGenericArgTypes(
-              abi,
-              arg.typeArguments,
-              typeParametersAndArgsMap
-            )
-          };
-        }
-        const argType = findOrThrow(abi.types, (t) => t.typeId === arg.type);
-        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
-        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
-          };
-        }
-        return arg;
-      });
-    }
-    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
-      if (!Array.isArray(args)) {
-        return null;
+    if (resolvedAbiType.type === VEC_CODER_TYPE) {
+      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Vec type is missing the 'type argument'.`
+        );
       }
-      const implicitGenericParameters = implicitGenericParametersParam ?? [];
-      args.forEach((a) => {
-        const argType = findOrThrow(abi.types, (t) => t.typeId === a.type);
-        if (genericRegEx.test(argType.type)) {
-          implicitGenericParameters.push(argType.typeId);
-          return;
-        }
-        if (!Array.isArray(a.typeArguments)) {
-          return;
-        }
-        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
-      });
-      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
+      const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
+      const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
+      return new VecCoder2(itemCoder);
     }
-    getSignature() {
-      const prefix = this.getArgSignaturePrefix();
-      const content = this.getArgSignatureContent();
-      return `${prefix}${content}`;
+    const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
+    if (structMatch) {
+      const coders = getCoders(components, { isRightPadded: true, getCoder: getCoder2 });
+      return new StructCoder2(structMatch.name, coders);
     }
-    getArgSignaturePrefix() {
-      const structMatch = structRegEx.test(this.type);
-      if (structMatch) {
-        return "s";
-      }
-      const arrayMatch = arrayRegEx.test(this.type);
-      if (arrayMatch) {
-        return "a";
-      }
-      const enumMatch = enumRegEx.test(this.type);
-      if (enumMatch) {
-        return "e";
+    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
+    if (enumMatch) {
+      const coders = getCoders(components, { getCoder: getCoder2 });
+      const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
+      if (isOptionEnum) {
+        return new OptionCoder(enumMatch.name, coders);
       }
-      return "";
+      return new EnumCoder2(enumMatch.name, coders);
     }
-    getArgSignatureContent() {
-      if (this.type === "raw untyped ptr") {
-        return "rawptr";
-      }
-      if (this.type === "raw untyped slice") {
-        return "rawslice";
-      }
-      const strMatch = stringRegEx.exec(this.type)?.groups;
-      if (strMatch) {
-        return `str[${strMatch.length}]`;
-      }
-      if (this.components === null) {
-        return this.type;
-      }
-      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
-      if (arrayMatch) {
-        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
-      }
-      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
-      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
-      return `${typeArgumentsSignature}${componentsSignature}`;
+    const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
+    if (tupleMatch) {
+      const coders = components.map(
+        (component) => getCoder2(component, { isRightPadded: true, encoding: ENCODING_V0 })
+      );
+      return new TupleCoder2(coders);
+    }
+    if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
+      throw new FuelError(
+        ErrorCode.INVALID_DATA,
+        "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
+      );
     }
+    throw new FuelError(
+      ErrorCode.CODER_NOT_FOUND,
+      `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
+    );
   };
+  function getCoderForEncoding(encoding = ENCODING_V0) {
+    switch (encoding) {
+      case ENCODING_V1:
+        return getCoder2;
+      case ENCODING_V0:
+        return getCoder;
+      default:
+        throw new FuelError(
+          ErrorCode.UNSUPPORTED_ENCODING_VERSION,
+          `Encoding version ${encoding} is unsupported.`
+        );
+    }
+  }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
       isSmallBytes: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
-      return AbiCoder.getCoderImpl(resolvedAbiType, options);
+      return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
     }
     static encode(abi, argument, value, options) {
       return this.getCoder(abi, argument, options).encode(value);
@@ -37360,103 +37617,6 @@ spurious results.`);
     static decode(abi, argument, data, offset, options) {
       return this.getCoder(abi, argument, options).decode(data, offset);
     }
-    static getCoderImpl(resolvedAbiType, options = {
-      isSmallBytes: false
-    }) {
-      const { version: version2 } = options;
-      switch (resolvedAbiType.type) {
-        case "u8":
-        case "u16":
-        case "u32":
-          return version2 ? new NumberCoder2(resolvedAbiType.type) : new NumberCoder(resolvedAbiType.type, options);
-        case "u64":
-        case "raw untyped ptr":
-          return new U64Coder();
-        case "raw untyped slice":
-          return version2 ? new RawSliceCoder2() : new RawSliceCoder();
-        case "bool":
-          return version2 ? new BooleanCoder2() : new BooleanCoder(options);
-        case "b256":
-          return new B256Coder();
-        case "struct B512":
-          return new B512Coder();
-        case BYTES_CODER_TYPE:
-          return version2 ? new ByteCoder2() : new ByteCoder();
-        case STD_STRING_CODER_TYPE:
-          return version2 ? new StdStringCoder2() : new StdStringCoder();
-        default:
-          break;
-      }
-      const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
-      if (stringMatch) {
-        const length = parseInt(stringMatch.length, 10);
-        return version2 ? new StringCoder2(length) : new StringCoder(length);
-      }
-      const components = resolvedAbiType.components;
-      const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
-      if (arrayMatch) {
-        const length = parseInt(arrayMatch.length, 10);
-        const arg = components[0];
-        if (!arg) {
-          throw new FuelError(
-            ErrorCode.INVALID_COMPONENT,
-            `The provided Array type is missing an item of 'component'.`
-          );
-        }
-        const arrayElementCoder = AbiCoder.getCoderImpl(arg, { version: version2, isSmallBytes: true });
-        return new ArrayCoder(arrayElementCoder, length);
-      }
-      if (resolvedAbiType.type === VEC_CODER_TYPE) {
-        const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
-        if (!arg) {
-          throw new FuelError(
-            ErrorCode.INVALID_COMPONENT,
-            `The provided Vec type is missing the 'type argument'.`
-          );
-        }
-        const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-        const itemCoder = AbiCoder.getCoderImpl(argType, { version: version2, isSmallBytes: true });
-        return version2 ? new VecCoder2(itemCoder) : new VecCoder(itemCoder);
-      }
-      const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
-      if (structMatch) {
-        const coders = AbiCoder.getCoders(components, { version: version2, isRightPadded: true });
-        return version2 ? new StructCoder2(structMatch.name, coders) : new StructCoder(structMatch.name, coders);
-      }
-      const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
-      if (enumMatch) {
-        const coders = AbiCoder.getCoders(components, { version: version2 });
-        const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
-        if (isOptionEnum) {
-          return new OptionCoder(enumMatch.name, coders);
-        }
-        return version2 ? new EnumCoder2(enumMatch.name, coders) : new EnumCoder(enumMatch.name, coders);
-      }
-      const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
-      if (tupleMatch) {
-        const coders = components.map(
-          (component) => AbiCoder.getCoderImpl(component, { version: version2, isRightPadded: true })
-        );
-        return version2 ? new TupleCoder2(coders) : new TupleCoder(coders);
-      }
-      if (resolvedAbiType.type === "str") {
-        throw new FuelError(
-          ErrorCode.INVALID_DATA,
-          "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
-        );
-      }
-      throw new FuelError(
-        ErrorCode.CODER_NOT_FOUND,
-        `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
-      );
-    }
-    static getCoders(components, options) {
-      return components.reduce((obj, component) => {
-        const o = obj;
-        o[component.name] = AbiCoder.getCoderImpl(component, options);
-        return o;
-      }, {});
-    }
   };
   var FunctionFragment = class {
     signature;
@@ -37664,7 +37824,7 @@ spurious results.`);
       }
       const { loggedType } = findOrThrow(this.jsonAbi.loggedTypes, (type3) => type3.logId === logId);
       return AbiCoder.decode(this.jsonAbi, loggedType, arrayify(data), 0, {
-        version: this.jsonAbi.encoding
+        encoding: this.jsonAbi.encoding
       });
     }
     updateExternalLoggedTypes(id, loggedTypes) {
@@ -43126,67 +43286,63 @@ ${MessageCoinFragmentFragmentDoc}`;
   }
 
   // src/providers/fuel-graphql-subscriber.ts
-  var _FuelSubscriptionStream = class {
-    readable;
-    writable;
-    readableStreamController;
-    constructor() {
-      this.readable = new ReadableStream({
-        start: (controller) => {
-          this.readableStreamController = controller;
-        }
-      });
-      this.writable = new WritableStream({
-        write: (bytes4) => {
-          const text = _FuelSubscriptionStream.textDecoder.decode(bytes4);
-          if (text.startsWith("data:")) {
-            const { data, errors } = JSON.parse(text.split("data:")[1]);
-            if (Array.isArray(errors)) {
-              this.readableStreamController.enqueue(
-                new FuelError(
-                  FuelError.CODES.INVALID_REQUEST,
-                  errors.map((err) => err.message).join("\n\n")
-                )
-              );
-            } else {
-              this.readableStreamController.enqueue(data);
-            }
-          }
+  var _FuelGraphqlSubscriber = class {
+    constructor(options) {
+      this.options = options;
+    }
+    stream;
+    async setStream() {
+      const { url, query, variables, fetchFn } = this.options;
+      const response = await fetchFn(`${url}-sub`, {
+        method: "POST",
+        body: JSON.stringify({
+          query: print(query),
+          variables
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
         }
       });
+      this.stream = response.body.getReader();
     }
-  };
-  var FuelSubscriptionStream = _FuelSubscriptionStream;
-  __publicField(FuelSubscriptionStream, "textDecoder", new TextDecoder());
-  async function* fuelGraphQLSubscriber({
-    url,
-    variables,
-    query,
-    fetchFn
-  }) {
-    const response = await fetchFn(`${url}-sub`, {
-      method: "POST",
-      body: JSON.stringify({
-        query: print(query),
-        variables
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "text/event-stream"
+    async next() {
+      if (!this.stream) {
+        await this.setStream();
       }
-    });
-    const subscriptionStreamReader = response.body.pipeThrough(new FuelSubscriptionStream()).getReader();
-    while (true) {
-      const { value, done } = await subscriptionStreamReader.read();
-      if (value instanceof FuelError) {
-        throw value;
-      }
-      yield value;
-      if (done) {
-        break;
+      while (true) {
+        const { value, done } = await this.stream.read();
+        if (done) {
+          return { value, done };
+        }
+        const text = _FuelGraphqlSubscriber.textDecoder.decode(value);
+        if (!text.startsWith("data:")) {
+          continue;
+        }
+        const { data, errors } = JSON.parse(text.split("data:")[1]);
+        if (Array.isArray(errors)) {
+          throw new FuelError(
+            FuelError.CODES.INVALID_REQUEST,
+            errors.map((err) => err.message).join("\n\n")
+          );
+        }
+        return { value: data, done: false };
       }
     }
-  }
+    /**
+     * Gets called when `break` is called in a `for-await-of` loop.
+     */
+    async return() {
+      await this.stream.cancel();
+      this.stream.releaseLock();
+      return { done: true, value: void 0 };
+    }
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+  __publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
   // src/providers/memory-cache.ts
   var cache = {};
@@ -44180,8 +44336,6 @@ ${MessageCoinFragmentFragmentDoc}`;
       this.inputs.forEach((i) => {
         let correspondingInput;
         switch (i.type) {
-          case InputType.Contract:
-            return;
           case InputType.Coin:
             correspondingInput = inputs.find((x) => x.type === InputType.Coin && x.owner === i.owner);
             break;
@@ -44191,7 +44345,7 @@ ${MessageCoinFragmentFragmentDoc}`;
             );
             break;
           default:
-            break;
+            return;
         }
         if (correspondingInput && "predicateGasUsed" in correspondingInput && bn(correspondingInput.predicateGasUsed).gt(0)) {
           i.predicate = correspondingInput.predicate;
@@ -44860,36 +45014,6 @@ ${MessageCoinFragmentFragmentDoc}`;
     }
     return allOperations;
   }
-  function getReceiptsTransferOut(receipts) {
-    return getReceiptsByType(receipts, ReceiptType.TransferOut);
-  }
-  function getContractTransferOperations({ receipts }) {
-    const transferOutReceipts = getReceiptsTransferOut(receipts);
-    const contractTransferOperations = transferOutReceipts.reduce(
-      (prevContractTransferOps, receipt) => {
-        const newContractTransferOps = addOperation(prevContractTransferOps, {
-          name: "Contract transfer" /* contractTransfer */,
-          from: {
-            type: 0 /* contract */,
-            address: receipt.from
-          },
-          to: {
-            type: 1 /* account */,
-            address: receipt.to
-          },
-          assetsSent: [
-            {
-              amount: receipt.amount,
-              assetId: receipt.assetId
-            }
-          ]
-        });
-        return newContractTransferOps;
-      },
-      []
-    );
-    return contractTransferOperations;
-  }
   function getWithdrawFromFuelOperations({
     inputs,
     receipts
@@ -44987,70 +45111,77 @@ ${MessageCoinFragmentFragmentDoc}`;
     }, []);
     return contractCallOperations;
   }
+  function extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs) {
+    const { to: toAddress, assetId, amount } = receipt;
+    let { from: fromAddress } = receipt;
+    const toType = contractInputs.some((input) => input.contractID === toAddress) ? 0 /* contract */ : 1 /* account */;
+    if (ZeroBytes32 === fromAddress) {
+      const change = changeOutputs.find((output4) => output4.assetId === assetId);
+      fromAddress = change?.to || fromAddress;
+    }
+    const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
+    return {
+      name: "Transfer asset" /* transfer */,
+      from: {
+        type: fromType,
+        address: fromAddress
+      },
+      to: {
+        type: toType,
+        address: toAddress
+      },
+      assetsSent: [
+        {
+          assetId: assetId.toString(),
+          amount
+        }
+      ]
+    };
+  }
   function getTransferOperations({
     inputs,
     outputs,
     receipts
   }) {
+    let operations = [];
     const coinOutputs = getOutputsCoin(outputs);
-    const [transferReceipt] = getReceiptsByType(
+    const contractInputs = getInputsContract(inputs);
+    const changeOutputs = getOutputsChange(outputs);
+    coinOutputs.forEach((output4) => {
+      const { amount, assetId, to } = output4;
+      const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
+      if (changeOutput) {
+        operations = addOperation(operations, {
+          name: "Transfer asset" /* transfer */,
+          from: {
+            type: 1 /* account */,
+            address: changeOutput.to
+          },
+          to: {
+            type: 1 /* account */,
+            address: to
+          },
+          assetsSent: [
+            {
+              assetId,
+              amount
+            }
+          ]
+        });
+      }
+    });
+    const transferReceipts = getReceiptsByType(
       receipts,
       ReceiptType.Transfer
     );
-    let operations = [];
-    if (transferReceipt) {
-      const changeOutputs = getOutputsChange(outputs);
-      changeOutputs.forEach((output4) => {
-        const { assetId } = output4;
-        const [contractInput] = getInputsContract(inputs);
-        const utxo = getInputFromAssetId(inputs, assetId);
-        if (utxo && contractInput) {
-          const inputAddress = getInputAccountAddress(utxo);
-          operations = addOperation(operations, {
-            name: "Transfer asset" /* transfer */,
-            from: {
-              type: 1 /* account */,
-              address: inputAddress
-            },
-            to: {
-              type: 0 /* contract */,
-              address: contractInput.contractID
-            },
-            assetsSent: [
-              {
-                assetId: assetId.toString(),
-                amount: transferReceipt.amount
-              }
-            ]
-          });
-        }
-      });
-    } else {
-      coinOutputs.forEach((output4) => {
-        const input = getInputFromAssetId(inputs, output4.assetId);
-        if (input) {
-          const inputAddress = getInputAccountAddress(input);
-          const operationToAdd = {
-            name: "Transfer asset" /* transfer */,
-            from: {
-              type: 1 /* account */,
-              address: inputAddress
-            },
-            to: {
-              type: 1 /* account */,
-              address: output4.to.toString()
-            },
-            assetsSent: [
-              {
-                assetId: output4.assetId.toString(),
-                amount: output4.amount
-              }
-            ]
-          };
-          operations = addOperation(operations, operationToAdd);
-        }
-      });
-    }
+    const transferOutReceipts = getReceiptsByType(
+      receipts,
+      ReceiptType.TransferOut
+    );
+    [...transferReceipts, ...transferOutReceipts].forEach((receipt) => {
+      const operation = extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs);
+      operations = addOperation(operations, operation);
+    });
     return operations;
   }
   function getPayProducerOperations(outputs) {
@@ -45123,7 +45254,6 @@ ${MessageCoinFragmentFragmentDoc}`;
           rawPayload,
           maxInputs
         }),
-        ...getContractTransferOperations({ receipts }),
         ...getWithdrawFromFuelOperations({ inputs, receipts })
       ];
     }
@@ -45679,7 +45809,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         const opDefinition = query.definitions.find((x) => x.kind === "OperationDefinition");
         const isSubscription = opDefinition?.operation === "subscription";
         if (isSubscription) {
-          return fuelGraphQLSubscriber({
+          return new FuelGraphqlSubscriber({
             url: this.url,
             query,
             fetchFn: (url, requestInit) => fetchFn(url, requestInit, this.options),
@@ -45871,11 +46001,15 @@ ${MessageCoinFragmentFragmentDoc}`;
     async estimateTxDependencies(transactionRequest) {
       if (transactionRequest.type === TransactionType.Create) {
         return {
-          receipts: []
+          receipts: [],
+          outputVariables: 0,
+          missingContractIds: []
         };
       }
       await this.estimatePredicates(transactionRequest);
       let receipts = [];
+      const missingContractIds = [];
+      let outputVariables = 0;
       for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
         const { dryRun: gqlReceipts } = await this.operations.dryRun({
           encodedTransaction: hexlify(transactionRequest.toTransactionBytes()),
@@ -45885,16 +46019,20 @@ ${MessageCoinFragmentFragmentDoc}`;
         const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
         const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
         if (hasMissingOutputs) {
+          outputVariables += missingOutputVariables.length;
           transactionRequest.addVariableOutputs(missingOutputVariables.length);
           missingOutputContractIds.forEach(({ contractId }) => {
             transactionRequest.addContractInputAndOutput(Address.fromString(contractId));
+            missingContractIds.push(contractId);
           });
         } else {
           break;
         }
       }
       return {
-        receipts
+        receipts,
+        outputVariables,
+        missingContractIds
       };
     }
     /**
@@ -45962,11 +46100,15 @@ ${MessageCoinFragmentFragmentDoc}`;
       const minGas = txRequestClone.calculateMinGas(chainInfo);
       const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
       let receipts = [];
+      let missingContractIds = [];
+      let outputVariables = 0;
       if (isScriptTransaction && estimateTxDependencies) {
         txRequestClone.gasPrice = bn(0);
         txRequestClone.gasLimit = bn(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
         const result = await this.estimateTxDependencies(txRequestClone);
         receipts = result.receipts;
+        outputVariables = result.outputVariables;
+        missingContractIds = result.missingContractIds;
       }
       const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
       const usedFee = calculatePriceWithFactor(
@@ -45988,7 +46130,8 @@ ${MessageCoinFragmentFragmentDoc}`;
         minFee,
         maxFee,
         estimatedInputs: txRequestClone.inputs,
-        estimatedOutputs: txRequestClone.outputs
+        outputVariables,
+        missingContractIds
       };
     }
     async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {