chore!: support new encoding schema

.changeset/shy-dodos-occur.md

@@ -0,0 +1,7 @@
+---
+"@fuel-ts/abi-typegen": minor
+"@fuel-ts/abi-coder": minor
+"fuels": minor
+---
+
+chore!: support new encoding schema

apps/demo-typegen/contract/Forc.toml

@@ -4,3 +4,6 @@ license = "Apache-2.0"
 name = "demo-contract"
 
 [dependencies]
+
+[patch.'https://github.com/fuellabs/sway']
+std = { git = "https://github.com/fuellabs/sway", branch = "esdrubal/abi_changes" }

apps/demo-typegen/predicate/Forc.toml

@@ -5,3 +5,6 @@ license = "Apache-2.0"
 name = "predicate"
 
 [dependencies]
+
+[patch.'https://github.com/fuellabs/sway']
+std = { git = "https://github.com/fuellabs/sway", branch = "esdrubal/abi_changes" }

apps/demo-typegen/script/Forc.toml

@@ -5,3 +5,6 @@ license = "Apache-2.0"
 name = "script"
 
 [dependencies]
+
+[patch.'https://github.com/fuellabs/sway']
+std = { git = "https://github.com/fuellabs/sway", branch = "esdrubal/abi_changes" }

apps/docs-snippets/src/guide/encoding/encode-and-decode.test.ts

@@ -1,13 +1,12 @@
 import {
   FUEL_NETWORK_URL,
   Provider,
-  AbiCoder,
   Script,
   ReceiptType,
   arrayify,
   buildFunctionResult,
 } from 'fuels';
-import type { Account, JsonAbi, JsonAbiArgument, TransactionResultReturnDataReceipt } from 'fuels';
+import type { Account, JsonAbi, TransactionResultReturnDataReceipt } from 'fuels';
 import { generateTestWallet } from 'fuels/test-utils';
 
 import abiSnippet from '../../../test/fixtures/abi/encode-and-decode.jsonc';
@@ -52,18 +51,12 @@ describe('encode and decode', () => {
     // #endregion encode-and-decode-3
 
     // #region encode-and-decode-4
-    // #import { JsonAbiArgument, AbiCoder};
 
-    // Now we can encode the argument we want to pass to the function. The argument is required
-    // as a function parameter for all `AbiCoder` functions and we can extract it from the ABI itself
-    const argument: JsonAbiArgument = abi.functions
-      .find((f) => f.name === 'main')
-      ?.inputs.find((i) => i.name === 'inputted_amount') as JsonAbiArgument;
-
-    // Using the `AbiCoder`'s `encode` method,  we can now create the encoding required for
-    // a u32 which takes 4 bytes up of property space
+    // Now we can encode the argument we want to pass to the function.
+    // Using the script's `interface` property, we select the `main` function and call its `encodeArguments` method.
+    // With this, we can now create the encoding required for a u32 which takes 4 bytes up of property space
     const argumentToAdd = 10;
-    const encodedArguments = AbiCoder.encode(abi, argument, [argumentToAdd]);
+    const encodedArguments = script.interface.functions.main.encodeArguments([argumentToAdd]);
     // Therefore the value of 10 will be encoded to:
     // Uint8Array([0, 0, 0, 10]
 
@@ -82,7 +75,7 @@ describe('encode and decode', () => {
     // #endregion encode-and-decode-4
 
     // #region encode-and-decode-5
-    // #import { AbiCoder, ReceiptType, TransactionResultReturnDataReceipt, arrayify, buildFunctionResult };
+    // #import { ReceiptType, TransactionResultReturnDataReceipt, arrayify, buildFunctionResult };
 
     // Get result of the transaction, including the contract call result. For this we'll need
     // the previously created invocation scope, the transaction response and the script
@@ -109,8 +102,8 @@ describe('encode and decode', () => {
     // returnData = new Uint8Array([0, 0, 0, 20]
 
     // And now we can decode the returned bytes in a similar fashion to how they were
-    // encoded, via the `AbiCoder`
-    const [decodedReturnData] = AbiCoder.decode(abi, argument, returnData, 0);
+    // encoded, via the `Interface` instance on the script variable
+    const [decodedReturnData] = script.interface.functions.main.decodeOutput(returnData);
     // 20
     // #endregion encode-and-decode-5
 

apps/docs-snippets/test/fixtures/abi/encode-and-decode.jsonc

@@ -1,29 +1,25 @@
 // #region encode-and-decode-2
 {
-  "encoding": "1",
-  "types": [
+  "programType": "script",
+  "specVersion": "1",
+  "encodingVersion": "1",
+  "concreteTypes": [
     {
-      "typeId": 0,
       "type": "u32",
-      "components": null,
-      "typeParameters": null,
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
     },
   ],
+  "metadataTypes": [],
   "functions": [
     {
       "inputs": [
         {
           "name": "inputted_amount",
-          "type": 0,
-          "typeArguments": null,
+          "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
         },
       ],
       "name": "main",
-      "output": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null,
-      },
+      "output": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
       "attributes": null,
     },
   ],
@@ -32,14 +28,9 @@
   "configurables": [
     {
       "name": "AMOUNT",
-      "configurableType": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null,
-      },
+      "concreteTypeId": "d7649d428b9ff33d188ecbf38a7e4d8fd167fa01b2e10fe9a8f9308e52f1d7cc",
       "offset": 856,
     },
   ],
 }
-
 // #endregion encode-and-decode-2

apps/docs-snippets/test/fixtures/forc-projects/Forc.toml

@@ -35,3 +35,6 @@ members = [
   "bytecode-input",
   "configurable-pin",
 ]
+
+[patch.'https://github.com/fuellabs/sway']
+std = { git = "https://github.com/fuellabs/sway", branch = "esdrubal/abi_changes" }

apps/docs/src/guide/encoding/encode-and-decode.md

@@ -26,7 +26,7 @@ It will produce the following ABI:
 
 <<< @/../../docs-snippets/test/fixtures/abi/encode-and-decode.jsonc#encode-and-decode-2{json:line-numbers}
 
-Now, let's prepare some data to pass to the `main` function to retrieve the combined integer. The function expects and returns a `u32` integer. So here, we will encode the `u32` to pass it to the function and receive the same `u32` back, as bytes, that we'll use for decoding. We can do both of these with the `AbiCoder`.
+Now, let's prepare some data to pass to the `main` function to retrieve the combined integer. The function expects and returns a `u32` integer. So here, we will encode the `u32` to pass it to the function and receive the same `u32` back, as bytes, that we'll use for decoding. We can do both of these with the `Interface` instance present on the `Script` instance's `interface property.
 
 First, let's prepare the transaction:
 

internal/forc/VERSION

@@ -1 +1 @@
-0.62.0
+git:esdrubal/abi_changes

internal/forc/lib/shared.js

@@ -56,7 +56,10 @@ export const buildFromGitBranch = (branchName) => {
   const stdioOpts = { stdio: 'inherit' };
 
   if (existsSync(swayRepoDir)) {
-    execSync(`cd ${swayRepoDir} && git fetch origin && git checkout ${branchName}`, stdioOpts);
+    execSync(
+      `cd ${swayRepoDir} && git fetch origin && git checkout ${branchName} && git reset --hard origin/${branchName}`,
+      stdioOpts
+    );
     execSync(`cd ${swayRepoDir} && cargo build`, stdioOpts);
   } else {
     execSync(`git clone --branch ${branchName} ${swayRepoUrl} ${swayRepoDir}`, stdioOpts);

packages/abi-coder/src/AbiCoder.ts

@@ -1,40 +1,28 @@
-import { ResolvedAbiType } from './ResolvedAbiType';
+import type { ResolvedType } from './ResolvedType';
 import type { DecodedValue, InputValue, Coder } from './encoding/coders/AbstractCoder';
 import { getCoderForEncoding } from './encoding/strategies/getCoderForEncoding';
 import type { EncodingOptions } from './types/EncodingOptions';
-import type { JsonAbi, JsonAbiArgument } from './types/JsonAbi';
 
 export abstract class AbiCoder {
   static getCoder(
-    abi: JsonAbi,
-    argument: JsonAbiArgument,
+    type: ResolvedType,
     options: EncodingOptions = {
       padToWordSize: false,
     }
   ): Coder {
-    const resolvedAbiType = new ResolvedAbiType(abi, argument);
-    return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
+    return getCoderForEncoding(options.encoding)(type, options);
   }
 
-  static encode(
-    abi: JsonAbi,
-    argument: JsonAbiArgument,
-    value: InputValue,
-    options?: EncodingOptions
-  ) {
-    return this.getCoder(abi, argument, options).encode(value);
+  static encode(type: ResolvedType, value: InputValue, options?: EncodingOptions) {
+    return this.getCoder(type, options).encode(value);
   }
 
   static decode(
-    abi: JsonAbi,
-    argument: JsonAbiArgument,
+    type: ResolvedType,
     data: Uint8Array,
     offset: number,
     options?: EncodingOptions
   ): [DecodedValue | undefined, number] {
-    return this.getCoder(abi, argument, options).decode(data, offset) as [
-      DecodedValue | undefined,
-      number,
-    ];
+    return this.getCoder(type, options).decode(data, offset) as [DecodedValue | undefined, number];
   }
 }

packages/abi-coder/src/FunctionFragment.ts

@@ -1,23 +1,16 @@
-import { bufferFromString } from '@fuel-ts/crypto';
 import { ErrorCode, FuelError } from '@fuel-ts/errors';
-import { sha256 } from '@fuel-ts/hasher';
 import type { BytesLike } from '@fuel-ts/interfaces';
-import { bn } from '@fuel-ts/math';
 import { arrayify } from '@fuel-ts/utils';
 
 import { AbiCoder } from './AbiCoder';
-import { ResolvedAbiType } from './ResolvedAbiType';
+import type { ResolvedType } from './ResolvedType';
 import type { DecodedValue, InputValue } from './encoding/coders/AbstractCoder';
 import { StdStringCoder } from './encoding/coders/StdStringCoder';
 import { TupleCoder } from './encoding/coders/TupleCoder';
-import type {
-  JsonAbi,
-  JsonAbiArgument,
-  JsonAbiFunction,
-  JsonAbiFunctionAttribute,
-} from './types/JsonAbi';
+import type { AbiFunction, JsonAbi, StorageAttr } from './types/JsonAbi';
 import type { EncodingVersion } from './utils/constants';
-import { OPTION_CODER_TYPE } from './utils/constants';
+import { optionRegEx } from './utils/constants';
+import { getFunctionSelector, getFunctionSignature } from './utils/functionSignatureUtils';
 import {
   findFunctionByName,
   findNonEmptyInputs,
@@ -34,37 +27,29 @@ export class FunctionFragment<
   readonly selectorBytes: Uint8Array;
   readonly encoding: EncodingVersion;
   readonly name: string;
-  readonly jsonFn: JsonAbiFunction;
-  readonly attributes: readonly JsonAbiFunctionAttribute[];
+  readonly jsonFn: AbiFunction;
+  readonly attributes: AbiFunction['attributes'];
 
-  private readonly jsonAbi: JsonAbi;
+  private readonly jsonAbi: TAbi;
 
-  constructor(jsonAbi: JsonAbi, name: FnName) {
+  constructor(
+    jsonAbi: TAbi,
+    private resolvedTypes: ResolvedType[],
+    name: FnName
+  ) {
     this.jsonAbi = jsonAbi;
     this.jsonFn = findFunctionByName(this.jsonAbi, name);
 
     this.name = name;
-    this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
-    this.selector = FunctionFragment.getFunctionSelector(this.signature);
+    this.signature = getFunctionSignature(this.jsonFn, resolvedTypes);
+
+    this.selector = getFunctionSelector(this.signature);
     this.selectorBytes = new StdStringCoder().encode(name);
-    this.encoding = getEncodingVersion(jsonAbi.encoding);
+    this.encoding = getEncodingVersion(jsonAbi.encodingVersion);
 
     this.attributes = this.jsonFn.attributes ?? [];
   }
 
-  private static getSignature(abi: JsonAbi, fn: JsonAbiFunction): string {
-    const inputsSignatures = fn.inputs.map((input) =>
-      new ResolvedAbiType(abi, input).getSignature()
-    );
-    return `${fn.name}(${inputsSignatures.join(',')})`;
-  }
-
-  private static getFunctionSelector(functionSignature: string) {
-    const hashedFunctionSignature = sha256(bufferFromString(functionSignature, 'utf-8'));
-    // get first 4 bytes of signature + 0x prefix. then left-pad it to 8 bytes using toHex(8)
-    return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
-  }
-
   encodeArguments(values: InputValue[]): Uint8Array {
     FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
 
@@ -77,26 +62,34 @@ export class FunctionFragment<
     }
 
     const coders = nonEmptyInputs.map((t) =>
-      AbiCoder.getCoder(this.jsonAbi, t, {
-        encoding: this.encoding,
-      })
+      AbiCoder.getCoder(
+        this.resolvedTypes.find((rt) => rt.typeId === t.concreteTypeId) as ResolvedType,
+        {
+          encoding: this.encoding,
+        }
+      )
     );
 
     return new TupleCoder(coders).encode(shallowCopyValues);
   }
 
   private static verifyArgsAndInputsAlign(
     args: InputValue[],
-    inputs: readonly JsonAbiArgument[],
+    inputs: AbiFunction['inputs'],
     abi: JsonAbi
   ) {
     if (args.length === inputs.length) {
       return;
     }
 
-    const inputTypes = inputs.map((input) => findTypeById(abi, input.type));
+    const inputTypes = inputs.map((input) => findTypeById(abi, input.concreteTypeId));
+
     const optionalInputs = inputTypes.filter(
-      (x) => x.type === OPTION_CODER_TYPE || x.type === '()'
+      (ct) =>
+        ct.type === '()' ||
+        optionRegEx.test(
+          abi.metadataTypes.find((tm) => tm.metadataTypeId === ct.metadataTypeId)?.type || ''
+        )
     );
     if (optionalInputs.length === inputTypes.length) {
       return;
@@ -143,7 +136,12 @@ export class FunctionFragment<
 
     const result = nonEmptyInputs.reduce(
       (obj: { decoded: unknown[]; offset: number }, input) => {
-        const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
+        const coder = AbiCoder.getCoder(
+          this.resolvedTypes.find((rt) => rt.typeId === input.concreteTypeId) as ResolvedType,
+          {
+            encoding: this.encoding,
+          }
+        );
         const [decodedValue, decodedValueByteSize] = coder.decode(bytes, obj.offset);
 
         return {
@@ -158,15 +156,18 @@ export class FunctionFragment<
   }
 
   decodeOutput(data: BytesLike): [DecodedValue | undefined, number] {
-    const outputAbiType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
+    const outputAbiType = findTypeById(this.jsonAbi, this.jsonFn.output);
     if (outputAbiType.type === '()') {
       return [undefined, 0];
     }
 
     const bytes = arrayify(data);
-    const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
-      encoding: this.encoding,
-    });
+    const coder = AbiCoder.getCoder(
+      this.resolvedTypes.find((rt) => rt.typeId === this.jsonFn.output) as ResolvedType,
+      {
+        encoding: this.encoding,
+      }
+    );
 
     return coder.decode(bytes, 0) as [DecodedValue | undefined, number];
   }
@@ -177,7 +178,9 @@ export class FunctionFragment<
    * @returns True if the function is read-only or pure, false otherwise.
    */
   isReadOnly(): boolean {
-    const storageAttribute = this.attributes.find((attr) => attr.name === 'storage');
+    const storageAttribute = this.attributes?.find((attr) => attr.name === 'storage') as
+      | StorageAttr
+      | undefined;
     return !storageAttribute?.arguments.includes('write');
   }
 }