feat!: adding abi transpiler

.changeset/odd-horses-cheer.md

@@ -0,0 +1,9 @@
+---
+"@fuel-ts/abi-typegen": patch
+"@fuel-ts/abi-coder": patch
+"@fuel-ts/versions": patch
+"@fuel-ts/utils": patch
+"@internal/forc": patch
+---
+
+feat: adding `abi` transpiler

apps/docs-snippets/src/guide/contracts/deploying-contracts.test.ts

@@ -1,8 +1,11 @@
-import { readFileSync } from 'fs';
+import { readFileSync as originalReadFileSync } from 'fs';
 import { Provider, FUEL_NETWORK_URL, Wallet, ContractFactory } from 'fuels';
 import { join } from 'path';
 
-import { DocSnippetProjectsEnum } from '../../../test/fixtures/forc-projects';
+import {
+  DocSnippetProjectsEnum,
+  getDocsSnippetsForcProject,
+} from '../../../test/fixtures/forc-projects';
 import { getTestWallet } from '../../utils';
 
 /**
@@ -13,6 +16,15 @@ describe(__filename, () => {
   let projectsPath: string;
   let contractName: string;
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function readFileSync(path: string | Buffer, encoding?: BufferEncoding): any {
+    if (/-abi\.json/.test(path.toString())) {
+      const abi = getDocsSnippetsForcProject(DocSnippetProjectsEnum.ECHO_VALUES);
+      return JSON.stringify(abi.abiContents, null, 2).toString();
+    }
+    return originalReadFileSync(path, encoding);
+  }
+
   beforeAll(async () => {
     const wallet = await getTestWallet();
     PRIVATE_KEY = wallet.privateKey;

internal/forc/VERSION

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

internal/forc/lib/shared.js

@@ -56,11 +56,20 @@
   const stdioOpts = { stdio: 'inherit' };
 
   if (existsSync(swayRepoDir)) {
-    execSync(`cd ${swayRepoDir} && git fetch origin && git checkout ${branchName}`, stdioOpts);
-    execSync(`cd ${swayRepoDir} && cargo build`, stdioOpts);
+    execSync(
+      [
+        `cd ${swayRepoDir}`,
+        `git fetch origin`,
+        `git checkout ${branchName}`,
+        `git pull origin ${branchName}`,
+      ].join('&&'),
+      stdioOpts
+    );
+
+    execSync(`cd ${swayRepoDir} && cargo build --release`, stdioOpts);
   } else {
     execSync(`git clone --branch ${branchName} ${swayRepoUrl} ${swayRepoDir}`, stdioOpts);
-    execSync(`cd ${swayRepoDir} && cargo build`, stdioOpts);
+    execSync(`cd ${swayRepoDir} && cargo build --release`, stdioOpts);
   }
 
   const [from, to] = [swayRepoDebugDir, forcBinDirPath];

internal/fuel-core/lib/shared.js

@@ -55,16 +55,16 @@ export const buildFromGitBranch = (branchName) => {
   const stdioOpts = { stdio: 'inherit' };
 
   if (existsSync(fuelCoreRepoDir)) {
-    spawnSync('git', ['pull'], { cwd: fuelCoreRepoDir, ...stdioOpts });
     spawnSync('git', ['checkout', branchName], { cwd: fuelCoreRepoDir, ...stdioOpts });
-    spawnSync('cargo', ['build'], { cwd: fuelCoreRepoDir, ...stdioOpts });
+    spawnSync('git', ['pull'], { cwd: fuelCoreRepoDir, ...stdioOpts });
+    spawnSync('cargo', ['build', '--release'], { cwd: fuelCoreRepoDir, ...stdioOpts });
   } else {
     spawnSync(
       'git',
       ['clone', '--branch', branchName, fuelCoreRepoUrl, fuelCoreRepoDir],
       stdioOpts
     );
-    spawnSync('cargo', ['build'], { cwd: fuelCoreRepoDir, ...stdioOpts });
+    spawnSync('cargo', ['build', '--release'], { cwd: fuelCoreRepoDir, ...stdioOpts });
   }
 
   const [from, to] = [fuelCoreRepoDebugDir, fuelCoreBinDirPath];

packages/abi-coder/src/FunctionFragment.ts

@@ -17,7 +17,7 @@ import type {
   JsonAbiFunctionAttribute,
 } from './types/JsonAbi';
 import type { EncodingVersion } from './utils/constants';
-import { OPTION_CODER_TYPE } from './utils/constants';
+import { optionCoderRegex } from './utils/constants';
 import {
   findFunctionByName,
   findNonEmptyInputs,
@@ -96,7 +96,7 @@ export class FunctionFragment<
 
     const inputTypes = inputs.map((input) => findTypeById(abi, input.type));
     const optionalInputs = inputTypes.filter(
-      (x) => x.type === OPTION_CODER_TYPE || x.type === '()'
+      (x) => optionCoderRegex.test(x.type) || x.type === '()'
     );
     if (optionalInputs.length === inputTypes.length) {
       return;

packages/abi-coder/src/encoding/coders/EnumCoder.ts

@@ -3,7 +3,7 @@ import { toNumber } from '@fuel-ts/math';
 import { concat } from '@fuel-ts/utils';
 import type { RequireExactlyOne } from 'type-fest';
 
-import { OPTION_CODER_TYPE } from '../../utils/constants';
+import { optionCoderRegex } from '../../utils/constants';
 import { hasNestedOption } from '../../utils/utilities';
 
 import type { TypesOfCoder } from './AbstractCoder';
@@ -39,13 +39,13 @@ export class EnumCoder<TCoders extends Record<string, Coder>> extends Coder<
     this.coders = coders;
     this.#caseIndexCoder = caseIndexCoder;
     this.#encodedValueSize = encodedValueSize;
-    this.#shouldValidateLength = !(this.type === OPTION_CODER_TYPE || hasNestedOption(coders));
+    this.#shouldValidateLength = !(optionCoderRegex.test(this.type) || hasNestedOption(coders));
   }
 
   // We parse a native enum as an empty tuple, so we are looking for a tuple with no child coders.
   // The '()' is enough but the child coders is a stricter check.
   #isNativeEnum(coder: Coder): boolean {
-    if (this.type !== OPTION_CODER_TYPE && coder.type === '()') {
+    if (!optionCoderRegex.test(this.type) && coder.type === '()') {
       const tupleCoder = coder as TupleCoder<[]>;
       return tupleCoder.coders.length === 0;
     }

packages/abi-coder/src/encoding/strategies/getCoderV1.ts

@@ -22,6 +22,7 @@ import {
   VEC_CODER_TYPE,
   arrayRegEx,
   enumRegEx,
+  lastNameRegExMatch,
   stringRegEx,
   structRegEx,
   tupleRegEx,
@@ -122,21 +123,26 @@ export const getCoder: GetCoderFn = (
     return new VecCoder(itemCoder as Coder);
   }
 
-  const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
+  const structMatch = structRegEx.test(resolvedAbiType.type);
   if (structMatch) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [name] = resolvedAbiType.type.match(lastNameRegExMatch)!;
     const coders = getCoders(components, { getCoder });
-    return new StructCoder(structMatch.name, coders);
+    return new StructCoder(name, coders);
   }
 
-  const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
+  const enumMatch = enumRegEx.test(resolvedAbiType.type);
   if (enumMatch) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [name] = resolvedAbiType.type.match(lastNameRegExMatch)!;
+
     const coders = getCoders(components, { getCoder });
 
     const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
     if (isOptionEnum) {
-      return new OptionCoder(enumMatch.name, coders);
+      return new OptionCoder(name, coders);
     }
-    return new EnumCoder(enumMatch.name, coders);
+    return new EnumCoder(name, coders);
   }
 
   const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;

packages/abi-coder/src/utils/constants.ts

@@ -10,18 +10,24 @@ export const RAW_PTR_CODER_TYPE = 'raw untyped ptr';
 export const RAW_SLICE_CODER_TYPE = 'raw untyped slice';
 export const BOOL_CODER_TYPE = 'bool';
 export const B256_CODER_TYPE = 'b256';
-export const B512_CODER_TYPE = 'struct B512';
-export const OPTION_CODER_TYPE = 'enum Option';
-export const VEC_CODER_TYPE = 'struct Vec';
-export const BYTES_CODER_TYPE = 'struct Bytes';
-export const STD_STRING_CODER_TYPE = 'struct String';
+export const B512_CODER_TYPE = 'struct std::b512::B512';
+export const OPTION_CODER_TYPE = 'enum std::option::Option';
+export const VEC_CODER_TYPE = 'struct std::vec::Vec';
+export const BYTES_CODER_TYPE = 'struct std::bytes::Bytes';
+export const STD_STRING_CODER_TYPE = 'struct std::string::String';
 export const STR_SLICE_CODER_TYPE = 'str';
+
+export const optionCoderRegex = /^enum.+Option$/m;
+
 export const stringRegEx = /str\[(?<length>[0-9]+)\]/;
 export const arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
-export const structRegEx = /^struct (?<name>\w+)$/;
-export const enumRegEx = /^enum (?<name>\w+)$/;
+export const structRegEx = /struct.+/;
+export const enumRegEx = /^enum.+$/;
 export const tupleRegEx = /^\((?<items>.*)\)$/;
-export const genericRegEx = /^generic (?<name>\w+)$/;
+export const genericRegEx = /^generic.+$/;
+
+export const lastNameRegExMatch = /([^:\s]+)$/m;
+
 /**
  * Encoding versions
  */

packages/abi-coder/src/utils/utilities.test.ts

@@ -1,3 +1,4 @@
+import { OPTION_CODER_TYPE } from './constants';
 import { hasNestedOption, type TCoders } from './utilities';
 
 /**
@@ -15,7 +16,7 @@ describe('findNestedOption', () => {
         coders: {
           a: {
             name: 'tuple',
-            type: '(boolean, [enum Option; 3])',
+            type: `(boolean, [${OPTION_CODER_TYPE}; 3])`,
             encodedLength: 28,
             coders: [
               {
@@ -26,12 +27,12 @@ describe('findNestedOption', () => {
               },
               {
                 name: 'array',
-                type: '[enum Option; 3]',
+                type: `[${OPTION_CODER_TYPE}; 3]`,
                 encodedLength: 27,
                 // Deeply nested option
                 coder: {
                   name: 'Option',
-                  type: 'enum Option',
+                  type: `${OPTION_CODER_TYPE}`,
                   encodedLength: 9,
                   coders: {
                     None: { name: 'tuple', type: '()', encodedLength: 0, coders: [] },
@@ -65,7 +66,7 @@ describe('findNestedOption', () => {
         coders: {
           a: {
             name: 'tuple',
-            type: '(boolean, [enum Option; 3])',
+            type: `(boolean, [${OPTION_CODER_TYPE}; 3])`,
             encodedLength: 28,
             coders: [
               {
@@ -76,7 +77,7 @@ describe('findNestedOption', () => {
               },
               {
                 name: 'array',
-                type: '[enum Option; 3]',
+                type: `[${OPTION_CODER_TYPE}; 3]`,
                 encodedLength: 27,
                 coder: {
                   name: 'AnotherEnum',

packages/abi-coder/test/Interface.test.ts

@@ -2,11 +2,10 @@
 import type { BN } from '@fuel-ts/math';
 import { concat } from '@fuel-ts/utils';
 
-import { Interface } from '../src';
-/** @knipignore */
-import type { JsonAbiConfigurable } from '../src/json-abi';
+import { Interface } from '../src/Interface';
+import type { JsonAbiConfigurable } from '../src/types/JsonAbi';
 
-import exhaustiveExamplesAbi from './fixtures/forc-projects/exhaustive-examples/out/release/exhaustive-examples-abi.json';
+import { AbiCoderProjectsEnum, getCoderForcProject } from './fixtures/forc-projects';
 import {
   B256_DECODED,
   B256_ENCODED,
@@ -35,6 +34,10 @@ import {
   U8_MIN_ENCODED,
 } from './utils/constants';
 
+const exhaustiveExamplesAbi = getCoderForcProject(
+  AbiCoderProjectsEnum.EXHAUSTIVE_EXAMPLES
+).abiContents;
+
 const exhaustiveExamplesInterface = new Interface(exhaustiveExamplesAbi);
 
 /**
@@ -735,7 +738,7 @@ describe('Abi interface', () => {
 
   describe('abi types', () => {
     it('should return the correct type when it exists', () => {
-      const abiType = exhaustiveExamplesInterface.getTypeById(0);
+      const abiType = exhaustiveExamplesInterface.getTypeById(72);
       expect(abiType.type).toEqual('()');
       expect(abiType.components).toBeDefined();
       expect(abiType.typeParameters).toBeNull();

packages/abi-coder/test/fixtures/forc-projects/index.ts

@@ -0,0 +1,18 @@
+import { getForcProject } from '@fuel-ts/utils/test-utils';
+import { join } from 'path';
+
+import type { JsonAbi } from '../../../src';
+
+export enum AbiCoderProjectsEnum {
+  EXHAUSTIVE_EXAMPLES = 'exhaustive-examples',
+}
+
+export const getCoderForcProject = (
+  project: AbiCoderProjectsEnum,
+  build: 'release' | 'debug' = 'release'
+) =>
+  getForcProject<JsonAbi>({
+    projectDir: join(__dirname, project),
+    projectName: project,
+    build,
+  });

packages/abi-coder/tsconfig.json

@@ -3,5 +3,5 @@
   "compilerOptions": {
     "outDir": "./dist"
   },
-  "include": ["src"]
+  "include": ["src", "test"]
 }

packages/abi-typegen/package.json

@@ -43,10 +43,10 @@
     "dist"
   ],
   "scripts": {
-    "pretest": "run-s build:forc-callpaths build:forc",
+    "pretest": "run-s build:forc:debug build:forc:release",
     "build": "tsup",
-    "build:forc": "pnpm fuels-forc build -p test/fixtures/forc-projects --release",
-    "build:forc-callpaths": "pnpm fuels-forc build -p test/fixtures/forc-projects --json-abi-with-callpaths",
+    "build:forc:debug": "pnpm fuels-forc build -p test/fixtures/forc-projects",
+    "build:forc:release": "pnpm fuels-forc build -p test/fixtures/forc-projects --release",
     "postbuild": "tsx ../../scripts/postbuild.ts"
   },
   "license": "Apache-2.0",

packages/abi-typegen/src/abi/types/ArrayType.test.ts

@@ -52,7 +52,7 @@ describe('ArrayType.ts', () => {
     const rawTypes = project.abiContents.types;
     const types = rawTypes.map((rawAbiType: JsonAbiType) => makeType({ rawAbiType }));
 
-    const a = findType({ types, typeId: 1 }) as ArrayType;
+    const a = findType({ types, typeId: 0 }) as ArrayType;
 
     expect(a.attributes.inputLabel).toEqual(
       '[Generic1Input<Generic2Input<BigNumberish>, string>, Generic1Input<Generic2Input<BigNumberish>, string>]'

packages/abi-typegen/src/abi/types/EvmAddressType.test.ts

@@ -33,7 +33,7 @@ describe('EvmAddressType.ts', () => {
 
     parseTypeArguments.mockClear();
 
-    const evmAddress = findType({ types, typeId: 1 }) as EvmAddressType;
+    const evmAddress = findType({ types, typeId: 0 }) as EvmAddressType;
 
     expect(evmAddress.attributes.inputLabel).toEqual('EvmAddress');
     expect(evmAddress.attributes.outputLabel).toEqual('EvmAddress');

packages/abi-typegen/src/abi/types/ResultType.test.ts

@@ -19,7 +19,8 @@ describe('ResultType.ts', () => {
     const project = getTypegenForcProject(AbiTypegenProjectsEnum.FULL);
     const rawTypes = project.abiContents.types as JsonAbiType[];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return parseTypes({ rawAbiTypes: [rawTypes.find((t) => t.type === 'enum Result')!] })[0];
+    const rawAbiTypes = [rawTypes.find((t) => t.type === 'enum std::result::Result')!];
+    return parseTypes({ rawAbiTypes })[0];
   }
 
   test('should properly evaluate type suitability', () => {

packages/abi-typegen/src/abi/types/TupleType.test.ts

@@ -30,7 +30,7 @@ describe('TupleType.ts', () => {
 
     // validating `struct B`, with simple tuples on property `x`
     parseTypeArguments.mockClear();
-    const b = findType({ types, typeId: 0 }) as TupleType;
+    const b = findType({ types, typeId: 1 }) as TupleType;
 
     expect(b.attributes.inputLabel).toEqual('[boolean, BigNumberish]');
     expect(b.attributes.outputLabel).toEqual('[boolean, BN]');
@@ -40,7 +40,7 @@ describe('TupleType.ts', () => {
 
     // validating `struct C`, with nested (tuple) `typeArguments` on `b` property
     parseTypeArguments.mockClear();
-    const c = findType({ types, typeId: 1 }) as TupleType;
+    const c = findType({ types, typeId: 0 }) as TupleType;
 
     expect(c.attributes.inputLabel).toEqual(
       '[BigNumberish, StructAInput<StructBInput<BigNumberish>, string>]'

packages/abi-typegen/src/runTypegen.ts

@@ -1,4 +1,5 @@
 import { ErrorCode, FuelError } from '@fuel-ts/errors';
+import { transpileAbi } from '@fuel-ts/utils';
 import { readFileSync, writeFileSync } from 'fs';
 import { globSync } from 'glob';
 import mkdirp from 'mkdirp';
@@ -52,10 +53,13 @@ export function runTypegen(params: IGenerateFilesParams) {
     Assembling file paths x contents
   */
   const abiFiles = filepaths.map((filepath) => {
+    const raw = readFileSync(filepath, 'utf-8');
+    const transpiled = JSON.stringify(transpileAbi(JSON.parse(raw)), null, 2);
     const abi: IFile = {
       path: filepath,
-      contents: readFileSync(filepath, 'utf-8'),
+      contents: transpiled,
     };
+
     return abi;
   });