feat: add support for dynamic configurables

internal/forc/VERSION

@@ -1 +1 @@
-0.66.6
+git:xunilrj/dynamic-types-configurables

packages/abi-coder/src/Interface.ts

@@ -5,7 +5,7 @@ import { arrayify } from '@fuel-ts/utils';
 
 import { AbiCoder } from './AbiCoder';
 import { FunctionFragment } from './FunctionFragment';
-import type { DecodedValue, InputValue } from './encoding/coders/AbstractCoder';
+import type { Coder, DecodedValue, InputValue } from './encoding/coders/AbstractCoder';
 import type { JsonAbiArgument, JsonAbiOld } from './types/JsonAbi';
 import type { Configurable, JsonAbi } from './types/JsonAbiNew';
 import { type EncodingVersion } from './utils/constants';
@@ -88,26 +88,23 @@ export class Interface {
     });
   }
 
-  encodeType(concreteTypeId: string, value: InputValue): Uint8Array {
+  getCoder(concreteTypeId: string): Coder {
     const typeArg = parseConcreteType(
       this.jsonAbi,
       this.jsonAbiOld.types,
       concreteTypeId,
       ''
     ) as JsonAbiArgument;
-    return AbiCoder.encode(this.jsonAbiOld, typeArg, value, {
-      encoding: this.encoding,
-    });
+    return AbiCoder.getCoder(this.jsonAbiOld, typeArg, { encoding: this.encoding });
   }
 
-  decodeType(concreteTypeId: string, data: Uint8Array): [DecodedValue | undefined, number] {
-    const typeArg = parseConcreteType(
-      this.jsonAbi,
-      this.jsonAbiOld.types,
-      concreteTypeId,
-      ''
-    ) as JsonAbiArgument;
+  encodeType(concreteTypeId: string, value: InputValue): Uint8Array {
+    const coder = this.getCoder(concreteTypeId);
+    return coder.encode(value);
+  }
 
-    return AbiCoder.decode(this.jsonAbiOld, typeArg, data, 0, { encoding: this.encoding });
+  decodeType(concreteTypeId: string, data: Uint8Array): [DecodedValue | undefined, number] {
+    const coder = this.getCoder(concreteTypeId);
+    return coder.decode(data, 0) as [DecodedValue | undefined, number];
   }
 }

packages/abi-coder/src/types/JsonAbi.ts

@@ -54,4 +54,5 @@ export interface JsonAbiConfigurable {
   name: string;
   configurableType: JsonAbiArgument;
   offset: number;
+  indirect?: boolean;
 }

packages/abi-coder/src/types/JsonAbiNew.ts

@@ -98,4 +98,5 @@ export interface Configurable {
   readonly name: string;
   readonly concreteTypeId: string;
   readonly offset: number;
+  readonly indirect?: boolean;
 }

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

@@ -123,6 +123,7 @@ export function transpileAbi(abi) {
     name: conf.name,
     configurableType: parseConcreteType(abi, types, conf.concreteTypeId),
     offset: conf.offset,
+    indirect: conf.indirect ?? false,
   }));
 
   // 5. loggedTypes

packages/abi-typegen/src/types/interfaces/JsonAbi.ts

@@ -54,4 +54,5 @@ export interface JsonAbiConfigurable {
   name: string;
   configurableType: JsonAbiArgument;
   offset: number;
+  indirect?: boolean;
 }

packages/abi-typegen/src/types/interfaces/JsonAbiNew.ts

@@ -98,4 +98,5 @@ export interface Configurable {
   readonly name: string;
   readonly concreteTypeId: string;
   readonly offset: number;
+  readonly indirect?: boolean;
 }

packages/abi-typegen/src/utils/transpile-abi.ts

@@ -123,6 +123,7 @@ export function transpileAbi(abi) {
     name: conf.name,
     configurableType: parseConcreteType(abi, types, conf.concreteTypeId),
     offset: conf.offset,
+    indirect: conf.indirect ?? false,
   }));
 
   // 5. loggedTypes

packages/abi-typegen/test/fixtures/templates/contract-with-configurable/main.hbs

@@ -160,17 +160,20 @@ const abi = {
     {
       "name": "SHOULD_RETURN",
       "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
-      "offset": 2584
+      "offset": 2584,
+      "indirect": false
     },
     {
       "name": "AN_OPTION",
       "concreteTypeId": "2da102c46c7263beeed95818cd7bee801716ba8303dddafdcd0f6c9efda4a0f1",
-      "offset": 2560
+      "offset": 2560,
+      "indirect": false
     },
     {
       "name": "A_GENERIC_STRUCT",
       "concreteTypeId": "71df88006611ffff852cf617defb70f77adaf507305088cedd41d276c783aab0",
-      "offset": 2576
+      "offset": 2576,
+      "indirect": false
     }
   ]
 };

packages/abi-typegen/test/fixtures/templates/predicate-with-configurable/main.hbs

@@ -73,12 +73,14 @@ const abi = {
     {
       "name": "FEE",
       "concreteTypeId": "c89951a24c6ca28c13fd1cfdc646b2b656d69e61a92b91023be7eb58eb914b6b",
-      "offset": 888
+      "offset": 888,
+      "indirect": false
     },
     {
       "name": "ADDRESS",
       "concreteTypeId": "7c5ee1cecf5f8eacd1284feb5f0bf2bdea533a51e2f0c9aabe9236d335989f3b",
-      "offset": 856
+      "offset": 856,
+      "indirect": false
     }
   ]
 };

packages/abi-typegen/test/fixtures/templates/script-with-configurable/main.hbs

@@ -81,7 +81,8 @@ const abi = {
     {
       "name": "SHOULD_RETURN",
       "concreteTypeId": "b760f44fa5965c2474a3b471467a22c43185152129295af588b022ae50b50903",
-      "offset": 696
+      "offset": 696,
+      "indirect": false
     }
   ]
 };

packages/abi-typegen/test/utils/getNewAbiTypegen.ts

@@ -83,6 +83,7 @@ export function getNewAbiTypegen(
         typeArguments: null,
       },
       offset: 120,
+      indirect: false,
     },
   ];
 

packages/account/src/predicate/configurable.ts

@@ -0,0 +1,133 @@
+import { BigNumberCoder } from '@fuel-ts/abi-coder';
+import type { InputValue, Interface } from '@fuel-ts/abi-coder';
+import type { Configurable } from '@fuel-ts/abi-coder/dist/types/JsonAbiNew';
+import { ErrorCode, FuelError } from '@fuel-ts/errors';
+
+import { getBytecodeDataOffset } from '../utils/predicate-script-loader-instructions';
+
+export const createConfigurables = (opts: { bytecode: Uint8Array; abi: Interface }) => {
+  const { abi } = opts;
+  let bytecode = new Uint8Array(opts.bytecode);
+  const configurables = Object.values(abi.configurables);
+  const bytecodeDataOffset = getBytecodeDataOffset(bytecode);
+  const dynamicOffsetCoder = new BigNumberCoder('u64');
+
+  const getConfigurable = (name: string) => {
+    const configurable = configurables.find((conf) => conf.name === name);
+    if (!configurable) {
+      throw new FuelError(
+        ErrorCode.CONFIGURABLE_NOT_FOUND,
+        `A configurable with the '${name}' was not found in the ABI.`
+      );
+    }
+    return configurable;
+  };
+
+  const readIndirectOffset = ({ offset }: Pick<Configurable, 'offset'>) => {
+    const [dynamicOffsetBn] = dynamicOffsetCoder.decode(bytecode, offset);
+    const dynamicOffset = bytecodeDataOffset + dynamicOffsetBn.toNumber();
+    return dynamicOffset;
+  };
+
+  /**
+   * Readers
+   */
+  const readDirect = ({ name, concreteTypeId, offset }: Configurable) => {
+    const coder = abi.getCoder(concreteTypeId);
+    const [value] = coder.decode(bytecode, offset);
+    return { name, value };
+  };
+
+  const readIndirect = ({ name, concreteTypeId, offset }: Configurable) => {
+    const dynamicOffset = readIndirectOffset({ offset });
+    const coder = abi.getCoder(concreteTypeId);
+    const [value] = coder.decode(bytecode, dynamicOffset);
+    return { name, value };
+  };
+
+  const read = (configurable: Configurable) => {
+    const reader = configurable.indirect ? readIndirect : readDirect;
+    return reader(configurable);
+  };
+
+  /**
+   * Writers
+   */
+  const writeDirect = ({ name, offset }: Configurable, value: InputValue) => {
+    const encodedValue = abi.encodeConfigurable(name, value);
+    bytecode.set(encodedValue, offset);
+  };
+
+  const writeIndirect = ({ concreteTypeId, offset }: Configurable, value: InputValue) => {
+    const dynamicOffset = readIndirectOffset({ offset });
+
+    // Read the original value
+    const coder = abi.getCoder(concreteTypeId);
+    const [, originalOffset] = coder.decode(bytecode, dynamicOffset);
+    const originalLength = originalOffset - dynamicOffset;
+
+    // Encode the new value
+    const encodedValue = coder.encode(value);
+    const newLength = encodedValue.length;
+
+    // Update the bytecode
+    bytecode = new Uint8Array([
+      ...bytecode.slice(0, dynamicOffset),
+      ...encodedValue,
+      ...bytecode.slice(dynamicOffset + originalLength),
+    ]);
+
+    const additionalOffset = newLength - originalLength;
+
+    // Update the other dynamic configurable offsets
+    configurables
+      .filter((configurable) => configurable.indirect && configurable.offset > offset)
+      .forEach((configurable) => {
+        const newDynamicOffset = readIndirectOffset({ offset: configurable.offset });
+        const newOffset = newDynamicOffset + additionalOffset - bytecodeDataOffset;
+
+        const encodedOffset = dynamicOffsetCoder.encode(newOffset);
+        bytecode.set(encodedOffset, configurable.offset);
+      });
+  };
+
+  const write = (configurable: Configurable, value: InputValue) => {
+    const writer = configurable.indirect ? writeIndirect : writeDirect;
+    return writer(configurable, value);
+  };
+
+  return {
+    /**
+     * Reads the value of a configurable.
+     *
+     * @param name - The name of the configurable to read.
+     * @returns The value of the configurable.
+     */
+    read: (name: string) => read(getConfigurable(name)),
+    /**
+     * Reads all the configurables.
+     *
+     * @returns An array of all the configurables.
+     */
+    all: () => configurables.map(read),
+    /**
+     * Updates the bytecode with the new configurable values.
+     *
+     * @param configurableValues - The new configurable values to set.
+     * @returns The mutated bytecode.
+     */
+    set: (configurableValues: { [name: string]: unknown }) => {
+      // TODO: add assertions for no configurables
+
+      configurables
+        .sort((a, b) => b.offset - a.offset)
+        .filter((configurable) => Object.hasOwn(configurableValues, configurable.name))
+        .forEach((configurable) => {
+          const value = configurableValues[configurable.name];
+          write(configurable, value as InputValue);
+        });
+
+      return bytecode;
+    },
+  };
+};