fix: contract operation summary for multi-calls (#3897)

Author: Torres-ssf

.changeset/angry-donuts-enter.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+fix: contract operation summary for multi-calls

packages/account/src/providers/transaction-summary/call.ts

@@ -1,16 +1,13 @@
-import { type JsonAbi, decodeScriptData } from '@fuel-ts/abi-coder';
+import { type JsonAbi, StdStringCoder } from '@fuel-ts/abi-coder';
 import { Interface } from '@fuel-ts/abi-coder';
-import { FuelError, ErrorCode } from '@fuel-ts/errors';
-import type { BN } from '@fuel-ts/math';
+import { type BN } from '@fuel-ts/math';
 import type { ReceiptCall } from '@fuel-ts/transactions';
-import { TransactionCoder } from '@fuel-ts/transactions';
-import { arrayify } from '@fuel-ts/utils';
 
 type GetFunctionCallProps = {
   abi: JsonAbi;
   receipt: ReceiptCall;
-  rawPayload: string;
-  maxInputs: BN;
+  offset: number;
+  scriptData: Uint8Array;
 };
 
 export interface FunctionCall {
@@ -23,39 +20,29 @@ export interface FunctionCall {
 
 /**
  * Builds a FunctionCall object from a call receipt.
- *
- * Currently only supports the first function call, multicall is not supported.
- * This should be https://github.com/FuelLabs/fuels-ts/issues/3733.
  */
 export const getFunctionCall = ({
   abi,
   receipt,
-  rawPayload,
+  offset,
+  scriptData,
 }: GetFunctionCallProps): FunctionCall => {
-  const [transaction] = new TransactionCoder().decode(arrayify(rawPayload), 0);
-
-  if (!transaction.scriptData) {
-    throw new FuelError(
-      ErrorCode.NOT_SUPPORTED,
-      'Cannot get function calls for this transaction type.'
-    );
-  }
-
-  const { functionArgs, functionSelector } = decodeScriptData(
-    arrayify(transaction.scriptData),
-    abi
-  );
+  const [functionSelector, argumentsOffset] = new StdStringCoder().decode(scriptData, offset);
 
   const abiInterface = new Interface(abi);
   const functionFragment = abiInterface.getFunction(functionSelector);
   const inputs = functionFragment.jsonFn.inputs;
 
-  let argumentsProvided;
+  let argumentsProvided: Record<string, unknown> | undefined;
+
+  // Validate if the function has arguments before attempting to decode them
+  if (inputs.length) {
+    const functionArgsBytes = scriptData.slice(argumentsOffset);
+    const decodedArguments = functionFragment.decodeArguments(functionArgsBytes);
 
-  if (functionArgs) {
-    // put together decoded data with input names from abi
+    // Put together decoded data with input names from abi
     argumentsProvided = inputs.reduce((prev, input, index) => {
-      const value = functionArgs[index];
+      const value = decodedArguments?.[index];
       const name = input.name;
 
       if (name) {

packages/account/src/providers/transaction-summary/operations.test.ts

@@ -5,7 +5,6 @@ import { ReceiptType, TransactionType } from '@fuel-ts/transactions';
 import { ASSET_A, ASSET_B } from '@fuel-ts/utils/test-utils';
 
 import {
-  CONTRACT_CALL_ABI,
   MOCK_INPUT_COIN,
   MOCK_INPUT_CONTRACT,
   MOCK_INPUT_MESSAGE,
@@ -21,7 +20,6 @@ import {
   MOCK_RECEIPT_RETURN_DATA_2,
   MOCK_RECEIPT_SCRIPT_RESULT,
   MOCK_RECEIPT_TRANSFER_OUT,
-  MOCK_TRANSACTION_RAWPAYLOAD,
 } from '../../../test/fixtures/transaction-summary';
 import type {
   TransactionResultMessageOutReceipt,
@@ -97,69 +95,6 @@ describe('operations', () => {
       expect(operations[0]).toStrictEqual(expected);
     });
 
-    // TODO: Make getOperation tests to be e2e
-    it.skip('should ensure getContractCallOperations return contract call operations with calls details', () => {
-      const expected: Operation = {
-        name: OperationName.contractCall,
-        calls: [
-          {
-            functionName: 'mint_to_address',
-            functionSignature: 'mint_to_address(u64,s(b256),u64)',
-            argumentsProvided: {
-              address: {
-                value: '0xa5a77a7d97c6708b08de873528ae6879ef5e9900fbc2e3f3cb74e28917bf7038',
-              },
-              amount: '0x64',
-              amount2: '0x64',
-            },
-            amount: bn('0x5f5e100'),
-            assetId: ZeroBytes32,
-          },
-        ],
-        from: {
-          type: AddressType.account,
-          address: '0x3e7ddda4d0d3f8307ae5f1aed87623992c1c4decefec684936960775181b2302',
-        },
-        to: {
-          type: AddressType.contract,
-          address: '0x0a98320d39c03337401a4e46263972a9af6ce69ec2f35a5420b1bd35784c74b1',
-        },
-        assetsSent: [
-          {
-            amount: bn(100000000),
-            assetId: ZeroBytes32,
-          },
-        ],
-      };
-
-      const receipts: TransactionResultReceipt[] = [
-        MOCK_RECEIPT_CALL,
-        {
-          ...MOCK_RECEIPT_CALL,
-          to: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        },
-        MOCK_RECEIPT_TRANSFER_OUT,
-        MOCK_RECEIPT_RETURN_DATA_1,
-        MOCK_RECEIPT_RETURN_DATA_2,
-        MOCK_RECEIPT_SCRIPT_RESULT,
-      ];
-
-      const operations = getContractCallOperations({
-        inputs: [MOCK_INPUT_CONTRACT, MOCK_INPUT_COIN],
-        outputs: [MOCK_OUTPUT_CONTRACT, MOCK_OUTPUT_VARIABLE, MOCK_OUTPUT_CHANGE],
-        receipts,
-        abiMap: {
-          '0x0a98320d39c03337401a4e46263972a9af6ce69ec2f35a5420b1bd35784c74b1': CONTRACT_CALL_ABI,
-        },
-        rawPayload: MOCK_TRANSACTION_RAWPAYLOAD,
-        maxInputs: bn(255),
-        baseAssetId: ZeroBytes32,
-      });
-
-      expect(operations.length).toEqual(1);
-      expect(operations[0]).toStrictEqual(expected);
-    });
-
     it('should ensure getContractCallOperations return empty', () => {
       const operations = getContractCallOperations({
         inputs: [],

packages/account/src/providers/transaction-summary/operations.ts

@@ -1,9 +1,10 @@
 import { ZeroBytes32 } from '@fuel-ts/address/configs';
 import { ErrorCode, FuelError } from '@fuel-ts/errors';
 import type { BN } from '@fuel-ts/math';
-import { bn } from '@fuel-ts/math';
-import { ReceiptType, TransactionType } from '@fuel-ts/transactions';
+import { bn, toBytes } from '@fuel-ts/math';
+import { ReceiptType, TransactionCoder, TransactionType } from '@fuel-ts/transactions';
 import type { InputContract, Output, OutputChange, Input } from '@fuel-ts/transactions';
+import { arrayify, concat } from '@fuel-ts/utils';
 
 import type {
   TransactionResultReceipt,
@@ -13,7 +14,7 @@ import type {
   TransactionResultTransferReceipt,
 } from '../transaction-response';
 
-import type { FunctionCall } from './call';
+import { getFunctionCall, type FunctionCall } from './call';
 import {
   getInputFromAssetId,
   getInputAccountAddress,
@@ -269,24 +270,68 @@ export function getWithdrawFromFuelOperations({
   return withdrawFromFuelOperations;
 }
 
+/** @hidden */
+function findBytesSegmentIndex(whole: Uint8Array, segment: Uint8Array) {
+  for (let i = 0; i <= whole.length - segment.length; i++) {
+    let match = true;
+    for (let j = 0; j < segment.length; j++) {
+      if (whole[i + j] !== segment[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 /** @hidden */
 function getContractCalls(
   contractInput: InputContract,
   abiMap: AbiMap | undefined,
-  _receipt: TransactionResultCallReceipt,
-  _rawPayload: string,
-  _maxInputs: BN
+  receipt: TransactionResultCallReceipt,
+  scriptData?: Uint8Array
 ): FunctionCall[] {
+  const calls: FunctionCall[] = [];
+
   const abi = abiMap?.[contractInput.contractID];
-  if (!abi) {
-    return [];
+  if (!abi || !scriptData) {
+    return calls;
+  }
+
+  const bytesSegment = concat([
+    arrayify(receipt.to), // Contract ID (32 bytes)
+    toBytes(receipt.param1.toHex(), 8), // Function selector offset (8 bytes)
+    toBytes(receipt.param2.toHex(), 8), // Function args offset (8 bytes)
+  ]);
+
+  const segmentIndex = findBytesSegmentIndex(scriptData, bytesSegment);
+
+  /**
+   * If the byte segment is not found, it likely indicates a non-standard contract call, such as:
+   *
+   * 1. Manual External Call: A direct call from a Sway script or contract using
+   *    `abi(abi_interface, contract_id)` built-in Sway function.
+   *
+   * 2. Inline ASM Call: A call made using the ASM `call` instruction in Sway,
+   *    without setting `param1` and `param2` offsets just like the SDKs do.
+   *
+   * In these cases, the function call cannot be decoded.
+   */
+  const canDecodeFunctionCall = segmentIndex !== -1;
+
+  if (!canDecodeFunctionCall) {
+    return calls;
   }
 
-  // Until we can successfully decode all operations, including multicall we
-  // will just return an empty. This should then be reintroduced in
-  // https://github.com/FuelLabs/fuels-ts/issues/3733
-  return [];
-  // return [ getFunctionCall({ abi, receipt, rawPayload, maxInputs }) ];
+  const offset = segmentIndex + bytesSegment.length;
+
+  const call = getFunctionCall({ abi, receipt, offset, scriptData });
+  calls.push(call);
+
+  return calls;
 }
 
 /** @hidden */
@@ -307,8 +352,7 @@ function processCallReceipt(
   contractInput: InputContract,
   inputs: Input[],
   abiMap: AbiMap | undefined,
-  rawPayload: string,
-  maxInputs: BN,
+  scriptData: Uint8Array | undefined,
   baseAssetId: string
 ): Operation[] {
   const assetId = receipt.assetId === ZeroBytes32 ? baseAssetId : receipt.assetId;
@@ -318,7 +362,7 @@ function processCallReceipt(
   }
 
   const inputAddress = getInputAccountAddress(input);
-  const calls = getContractCalls(contractInput, abiMap, receipt, rawPayload, maxInputs);
+  const calls = getContractCalls(contractInput, abiMap, receipt, scriptData);
 
   return [
     {
@@ -345,7 +389,6 @@ export function getContractCallOperations({
   receipts,
   abiMap,
   rawPayload,
-  maxInputs,
   baseAssetId,
 }: InputOutputParam &
   ReceiptParam &
@@ -360,18 +403,19 @@ export function getContractCallOperations({
       return [];
     }
 
+    let scriptData: Uint8Array | undefined;
+
+    if (rawPayload) {
+      const [transaction] = new TransactionCoder().decode(arrayify(rawPayload), 0);
+      if (transaction.type === TransactionType.Script) {
+        scriptData = arrayify(transaction.scriptData as string);
+      }
+    }
+
     return contractCallReceipts
       .filter((receipt) => receipt.to === contractInput.contractID)
       .flatMap((receipt) =>
-        processCallReceipt(
-          receipt,
-          contractInput,
-          inputs,
-          abiMap,
-          rawPayload as string,
-          maxInputs,
-          baseAssetId
-        )
+        processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId)
       );
   });
 }