feat: support proxied contract calls

packages/fuel-gauge/src/contract.test.ts

@@ -13,14 +13,19 @@ import {
  Predicate,
  PolicyType,
  buildFunctionResult,
+ ReceiptType,
 } from 'fuels';
-import type { ScriptTransactionRequest, TransferParams } from 'fuels';
+import type { ScriptTransactionRequest, TransactionResultCallReceipt, TransferParams } from 'fuels';
 import { expectToThrowFuelError, ASSET_A, ASSET_B, launchTestNode } from 'fuels/test-utils';
 import type { DeployContractConfig } from 'fuels/test-utils';
 
 import {
  CallTestContract,
  CallTestContractFactory,
+ CoverageContract,
+ CoverageContractFactory,
+ ProxySrc14Contract,
+ ProxySrc14ContractFactory,
  StorageTestContract,
  StorageTestContractFactory,
 } from '../test/typegen/contracts';
@@ -1111,4 +1116,61 @@ describe('Contract', () => {
  expect(scriptGasLimit?.toNumber()).toBe(gasLimit);
  expect(bn(maxFeePolicy?.data).toNumber()).toBe(maxFee);
  });
+
+ it('can proper set a proxy contract and use it to call a target contract', async () => {
+ using launch = await launchTestNode({
+ contractsConfigs: [{ factory: CoverageContractFactory }],
+ });
+
+ const {
+ wallets: [wallet],
+ contracts: [coverageContract],
+ } = launch;
+
+ const proxyFactory = await ProxySrc14ContractFactory.deploy(wallet, {
+ storageSlots: ProxySrc14Contract.storageSlots,
+ });
+
+ const { contract: proxyContract } = await proxyFactory.waitForResult();
+
+ // Setting the contract target at the proxy
+ const call = await proxyContract.functions
+ .set_proxy_target({ bits: coverageContract.id.toB256() })
+ .call();
+
+ await call.waitForResult();
+
+ const proxyId = proxyContract.id;
+ const echoValuesId = coverageContract.id;
+
+ const proxiedConverageContract = new Contract(
+ echoValuesId,
+ CoverageContract.abi,
+ wallet,
+ proxyId
+ );
+
+ const echoAmount = 10;
+
+ const proxiedCall = await proxiedConverageContract.functions
+ .echo_u8(echoAmount)
+ .addContracts([proxyContract])
+ .call();
+
+ const {
+ value,
+ transactionResult: { receipts },
+ } = await proxiedCall.waitForResult();
+
+ const callReceipt = receipts.filter(
+ (receipt) => receipt.type === ReceiptType.Call
+ ) as TransactionResultCallReceipt[];
+
+ // Ensure called contract was the proxy contract
+ expect(callReceipt.length).toBe(1);
+ expect(callReceipt[0].to).toBe(proxyId.toB256());
+
+ // Ensure returned value is the expected one
+ expect(value).toBe(echoAmount);
+ });
 });

packages/fuel-gauge/test/fixtures/forc-projects/Forc.toml

@@ -55,6 +55,7 @@ members = [
  "script-raw-slice",
  "script-std-lib-string",
  "script-str-slice",
+ "proxy-src14-contract",
  "script-with-array",
  "script-with-configurable",
  "script-with-vector",

packages/fuel-gauge/test/fixtures/forc-projects/proxy-src14-contract/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "proxy-src14-contract"
+
+[dependencies]
+standards = { git = "https://github.com/FuelLabs/sway-standards", tag = "v0.6.1" }

packages/fuel-gauge/test/fixtures/forc-projects/proxy-src14-contract/src/main.sw

@@ -0,0 +1,38 @@
+contract;
+
+use std::execution::run_external;
+use standards::{src14::SRC14};
+
+pub enum ProxyErrors {
+ TargetNotSet: (),
+}
+
+configurable {
+ INITIAL_TARGET: ContractId = ContractId::zero(),
+}
+
+storage {
+ SRC14 {
+ target: Option<ContractId> = None,
+ },
+}
+
+impl SRC14 for Contract {
+ #[storage(read, write)]
+ fn set_proxy_target(new_target: ContractId) {
+ storage::SRC14.target.write(Some(new_target));
+ }
+
+ #[storage(read)]
+ fn proxy_target() -> Option<ContractId> {
+ Some(storage::SRC14.target.read().unwrap_or(INITIAL_TARGET))
+ }
+}
+
+#[fallback]
+#[storage(read)]
+fn fallback() {
+ let target = storage::SRC14.target.read().unwrap_or(INITIAL_TARGET);
+ require(target.bits() != b256::zero(), ProxyErrors::TargetNotSet);
+ run_external(target)
+}

packages/interfaces/src/index.ts

@@ -83,6 +83,7 @@ export abstract class AbstractProgram {
 
 export abstract class AbstractContract extends AbstractProgram {
  abstract id: AbstractAddress;
+ abstract proxyContractId?: AbstractAddress;
 }
 
 /**

packages/program/src/contract-call-script.ts

@@ -199,12 +199,14 @@ export const getContractCallScript = (
  const encodedArgs = arrayify(call.data);
  let gasForwardedOffset = 0;
 
+ const contractId = call.proxyContractId || call.contractId;
+
  // 1. Amount
  scriptData.push(new BigNumberCoder('u64').encode(call.amount || 0));
  // 2. Asset ID
  scriptData.push(new B256Coder().encode(call.assetId?.toString() || ZeroBytes32));
  // 3. Contract ID
- scriptData.push(call.contractId.toBytes());
+ scriptData.push(contractId.toBytes());
  // 4. Function selector offset
  scriptData.push(new BigNumberCoder('u64').encode(encodedSelectorOffset));
  // 5. Encoded argument offset

packages/program/src/contract.ts

@@ -17,6 +17,11 @@ export default class Contract implements AbstractContract {
  */
  id!: AbstractAddress;
 
+ /**
+ * Proxy contract identifier.
+ */
+ proxyContractId?: AbstractAddress;
+
  /**
  * The provider for interacting with the contract.
  */
@@ -47,10 +52,14 @@ export default class Contract implements AbstractContract {
  constructor(
  id: string | AbstractAddress,
  abi: JsonAbi | Interface,
- accountOrProvider: Account | Provider
+ accountOrProvider: Account | Provider,
+ proxyContractId?: string | AbstractAddress
  ) {
  this.interface = abi instanceof Interface ? abi : new Interface(abi);
  this.id = Address.fromAddressOrString(id);
+ if (proxyContractId) {
+ this.proxyContractId = Address.fromAddressOrString(proxyContractId);
+ }
 
  /**
  Instead of using `instanceof` to compare classes, we instead check

packages/program/src/functions/base-invocation-scope.ts

@@ -44,6 +44,7 @@ function createContractCall(funcScope: InvocationScopeLike): ContractCall {
 
  return {
  contractId: (program as AbstractContract).id,
+ proxyContractId: (program as AbstractContract).proxyContractId,
  fnSelectorBytes: func.selectorBytes,
  data,
  assetId: forward?.assetId,
@@ -119,7 +120,9 @@ export class BaseInvocationScope<TReturn = any> {
  protected updateContractInputAndOutput() {
  const calls = this.calls;
  calls.forEach((c) => {
- if (c.contractId) {
+ if (c.proxyContractId) {
+ this.transactionRequest.addContractInputAndOutput(c.proxyContractId);
+ } else if (c.contractId) {
  this.transactionRequest.addContractInputAndOutput(c.contractId);
  }
  if (c.externalContractsAbis) {

packages/program/src/response.ts

@@ -26,11 +26,12 @@ export const extractInvocationResult = <T>(
  if (functionScopes.length === 1 && mainCallConfig && 'bytes' in mainCallConfig.program) {
  return callResultToInvocationResult<T>({ receipts }, mainCallConfig, logs);
  }
- const encodedResults = decodeContractCallScriptResult(
- { receipts },
- (mainCallConfig?.program as AbstractContract).id,
- logs
- );
+
+ const contractId =
+ (mainCallConfig?.program as AbstractContract).proxyContractId ||
+ (mainCallConfig?.program as AbstractContract).id;
+
+ const encodedResults = decodeContractCallScriptResult({ receipts }, contractId, logs);
 
  const decodedResults = encodedResults.map((encodedResult, i) => {
  const { func } = functionScopes[i].getCallConfig();

packages/program/src/types.ts

@@ -17,6 +17,7 @@ import type { FunctionInvocationScope } from './functions/invocation-scope';
  */
 export type ContractCall = {
  contractId: AbstractAddress;
+ proxyContractId?: AbstractAddress;
  data: BytesLike;
  fnSelectorBytes: Uint8Array;
  amount?: BigNumberish;