feat: bytecode ID helpers (#3641)

* feat: bytecode id helpers

* chore: changeset

* chore: test groups

* chore: add doc

---------

Co-authored-by: Sérgio Torres <[email protected]>

Author: danielbate

.changeset/gorgeous-plants-watch.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+feat: bytecode ID helpers

packages/account/src/index.ts

@@ -11,3 +11,9 @@ export * from './predicate';
 export * from './providers';
 export * from './connectors';
 export { deployScriptOrPredicate } from './utils/deployScriptOrPredicate';
+export {
+  getBytecodeId,
+  getLegacyBlobId,
+  getBytecodeConfigurableOffset,
+  getBytecodeDataOffset,
+} from './utils/predicate-script-loader-instructions';

packages/account/src/utils/deployScriptOrPredicate.ts

@@ -1,14 +1,14 @@
 import type { JsonAbi } from '@fuel-ts/abi-coder';
 import { FuelError, ErrorCode } from '@fuel-ts/errors';
-import { hash } from '@fuel-ts/hasher';
 import { bn } from '@fuel-ts/math';
 import { arrayify } from '@fuel-ts/utils';
 
 import type { Account } from '../account';
 import { BlobTransactionRequest, calculateGasFee, TransactionStatus } from '../providers';
 
 import {
-  getConfigurableOffset,
+  getBytecodeConfigurableOffset,
+  getBytecodeId,
   getPredicateScriptLoaderInstructions,
 } from './predicate-script-loader-instructions';
 
@@ -63,11 +63,10 @@ export async function deployScriptOrPredicate<T>({
   abi,
   loaderInstanceCallback,
 }: Deployer<T>) {
-  const configurableOffset = getConfigurableOffset(arrayify(bytecode));
-  const byteCodeWithoutConfigurableSection = bytecode.slice(0, configurableOffset);
+  const blobId = getBytecodeId(arrayify(bytecode));
 
-  // Generate the associated create tx for the loader contract
-  const blobId = hash(byteCodeWithoutConfigurableSection);
+  const configurableOffset = getBytecodeConfigurableOffset(arrayify(bytecode));
+  const byteCodeWithoutConfigurableSection = bytecode.slice(0, configurableOffset);
 
   const blobTxRequest = new BlobTransactionRequest({
     blobId,

packages/account/src/utils/predicate-script-loader-instructions.test.ts

@@ -0,0 +1,39 @@
+import { concat } from '@fuel-ts/utils';
+
+import {
+  getBytecodeConfigurableOffset,
+  getBytecodeDataOffset,
+  getBytecodeId,
+  getLegacyBlobId,
+} from './predicate-script-loader-instructions';
+
+/**
+ * @group node
+ * @group browser
+ */
+describe('Predicate Script Loader Instructions', () => {
+  const suffixBytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
+  const dataBytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 3]);
+  const configurableBytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 5]);
+  const bytecode = concat([suffixBytes, dataBytes, configurableBytes]);
+
+  it('gets the data offset', () => {
+    const offset = getBytecodeDataOffset(bytecode);
+    expect(offset).toBe(3);
+  });
+
+  it('gets the configurable offset', () => {
+    const offset = getBytecodeConfigurableOffset(bytecode);
+    expect(offset).toBe(5);
+  });
+
+  it('gets the bytecode id', () => {
+    const id = getBytecodeId(bytecode);
+    expect(id).toBe('0x8855508aade16ec573d21e6a485dfd0a7624085c1a14b5ecdd6485de0c6839a4');
+  });
+
+  it('gets the legacy blob id', () => {
+    const id = getLegacyBlobId(bytecode);
+    expect(id).toBe('0x709e80c88487a2411e1ee4dfb9f22a861492d20c4765150c0c794abd70f8147c');
+  });
+});

packages/account/src/utils/predicate-script-loader-instructions.ts

@@ -1,3 +1,5 @@
+import { BigNumberCoder } from '@fuel-ts/abi-coder';
+import { sha256 } from '@fuel-ts/hasher';
 import { concat } from '@fuel-ts/utils';
 import * as asm from '@fuels/vm-asm';
 
@@ -7,16 +9,61 @@ const REG_START_OF_LOADED_CODE = 0x11;
 const REG_GENERAL_USE = 0x12;
 const WORD_SIZE = 8; // size in bytes
 
-export function getConfigurableOffset(binary: Uint8Array): number {
-  // Extract 8 bytes starting from index 16 (similar to binary[16..24] in Rust)
-  const OFFSET_INDEX = 16;
-  const dataView = new DataView(binary.buffer, OFFSET_INDEX, 8);
+export const DATA_OFFSET_INDEX = 8;
+export const CONFIGURABLE_OFFSET_INDEX = 16;
+
+/**
+ * Get the offset of the data section in the bytecode
+ *
+ * @param bytecode - The bytecode to get the offset from
+ * @returns The offset of the data section
+ */
+export function getBytecodeDataOffset(bytecode: Uint8Array): number {
+  const [offset] = new BigNumberCoder('u64').decode(bytecode, DATA_OFFSET_INDEX);
+  return offset.toNumber();
+}
+
+/**
+ * Get the offset of the configurable section in the bytecode
+ *
+ * @param bytecode - The bytecode to get the offset from
+ * @returns The offset of the configurable section
+ */
+export function getBytecodeConfigurableOffset(bytecode: Uint8Array): number {
+  const [offset] = new BigNumberCoder('u64').decode(bytecode, CONFIGURABLE_OFFSET_INDEX);
+  return offset.toNumber();
+}
 
-  // Read the value as a 64-bit big-endian unsigned integer
-  const dataOffset = dataView.getBigUint64(0, false); // false means big-endian
+/**
+ * Takes bytecode and generates it's associated bytecode ID.
+ *
+ * The bytecode ID is a hash of the bytecode when sliced at the configurable offset. This
+ * superseded legacy blob IDs when uploading blobs for scripts and predicates so that
+ * the bytecode ID is equal to the legacy blob ID. Therefore blobs can be used for ABI verification.
+ *
+ * @param bytecode - The bytecode to get the id from
+ * @returns The id of the bytecode
+ */
+export function getBytecodeId(bytecode: Uint8Array): string {
+  const configurableOffset = getBytecodeConfigurableOffset(bytecode);
+  const byteCodeWithoutConfigurableSection = bytecode.slice(0, configurableOffset);
+
+  return sha256(byteCodeWithoutConfigurableSection);
+}
 
-  // Convert the BigInt to a regular number (safe as long as the offset is within Number.MAX_SAFE_INTEGER)
-  return Number(dataOffset);
+/**
+ * Takes bytecode and generates it's associated legacy blob ID.
+ *
+ * The legacy blob ID is a hash of the bytecode when sliced at the data section offset.
+ *
+ * @param bytecode - The bytecode to get the id from
+ * @returns The id of the bytecode
+ */
+export function getLegacyBlobId(bytecode: Uint8Array): string {
+  const dataOffset = getBytecodeDataOffset(bytecode);
+  const byteCodeWithoutDataSection = bytecode.slice(0, dataOffset);
+
+  return sha256(byteCodeWithoutDataSection);
 }
 
 export function getPredicateScriptLoaderInstructions(
@@ -100,7 +147,7 @@ export function getPredicateScriptLoaderInstructions(
     asm.jmp(REG_START_OF_LOADED_CODE),
   ];
 
-  const offset = getConfigurableOffset(originalBinary);
+  const offset = getBytecodeConfigurableOffset(originalBinary);
 
   // if the binary length is smaller than the offset
   if (originalBinary.length < offset) {