feat: implement generateFakeResources on Account class

.changeset/lazy-readers-flash.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+feat: implement `generateFakeResources` on `Account` class

packages/account/src/account.test.ts

@@ -6,7 +6,7 @@ import { bn } from '@fuel-ts/math';
 import { PolicyType } from '@fuel-ts/transactions';
 import { ASSET_A, ASSET_B } from '@fuel-ts/utils/test-utils';
 
-import type { TransferParams } from './account';
+import type { FakeResources, TransferParams } from './account';
 import { Account } from './account';
 import { FUEL_NETWORK_URL } from './configs';
 import { ScriptTransactionRequest, Provider } from './providers';
@@ -659,6 +659,40 @@ describe('Account', () => {
     expect(receiverBalances).toEqual([{ assetId: baseAssetId, amount: bn(110) }]);
   });
 
+  it('can generate and use fake coins', async () => {
+    const sender = Wallet.generate({
+      provider,
+    });
+
+    const amount1 = bn(100_000);
+    const amount2 = bn(200_000);
+    const amount3 = bn(300_000);
+
+    const fakeCoinsConfig: FakeResources[] = [
+      { amount: amount1, assetId: baseAssetId },
+      { amount: amount2, assetId: ASSET_A },
+      { amount: amount3, assetId: ASSET_B },
+    ];
+
+    const fakeCoins = sender.generateFakeResources(fakeCoinsConfig);
+    const request = new ScriptTransactionRequest({
+      gasLimit: bn(1500),
+      maxFee: bn(1700),
+    });
+
+    request.addResources(fakeCoins);
+    request.addCoinOutput(Address.fromRandom(), amount1.div(3), baseAssetId);
+    request.addCoinOutput(Address.fromRandom(), amount2, ASSET_A);
+    request.addCoinOutput(Address.fromRandom(), amount3, ASSET_B);
+
+    const { dryRunStatus } = await provider.call(request, {
+      utxoValidation: false,
+      estimateTxDependencies: false,
+    });
+
+    expect(dryRunStatus?.type).toBe('DryRunSuccessStatus');
+  });
+
   it('can withdraw an amount of base asset using mutiple uxtos', async () => {
     const sender = Wallet.generate({
       provider,

packages/account/src/account.ts

@@ -1,10 +1,12 @@
+import { UTXO_ID_LEN } from '@fuel-ts/abi-coder';
 import { Address } from '@fuel-ts/address';
+import { randomBytes } from '@fuel-ts/crypto';
 import { ErrorCode, FuelError } from '@fuel-ts/errors';
 import { AbstractAccount } from '@fuel-ts/interfaces';
 import type { AbstractAddress, BytesLike } from '@fuel-ts/interfaces';
 import type { BigNumberish, BN } from '@fuel-ts/math';
 import { bn } from '@fuel-ts/math';
-import { arrayify, isDefined } from '@fuel-ts/utils';
+import { arrayify, hexlify, isDefined } from '@fuel-ts/utils';
 import { clone } from 'ramda';
 
 import type { FuelConnector } from './connectors';
@@ -56,6 +58,8 @@ export type EstimatedTxParams = Pick<
 >;
 const MAX_FUNDING_ATTEMPTS = 2;
 
+export type FakeResources = Partial<Coin> & Required<Pick<Coin, 'amount' | 'assetId'>>;
+
 /**
  * `Account` provides an abstraction for interacting with accounts or wallets on the network.
  */
@@ -642,6 +646,22 @@ export class Account extends AbstractAccount {
     return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
   }
 
+  /**
+   * Generates an array of fake resources based on the provided coins.
+   *
+   * @param coins - An array of `FakeResources` objects representing the coins.
+   * @returns An array of `Resource` objects with generated properties.
+   */
+  generateFakeResources(coins: FakeResources[]): Array<Resource> {
+    return coins.map((coin) => ({
+      id: hexlify(randomBytes(UTXO_ID_LEN)),
+      owner: this.address,
+      blockCreated: bn(1),
+      txCreatedIdx: bn(1),
+      ...coin,
+    }));
+  }
+
   /** @hidden * */
   private validateTransferAmount(amount: BigNumberish) {
     if (bn(amount).lte(0)) {

packages/account/src/predicate/predicate.ts

@@ -5,6 +5,7 @@ import { ErrorCode, FuelError } from '@fuel-ts/errors';
 import type { BytesLike } from '@fuel-ts/interfaces';
 import { arrayify, hexlify } from '@fuel-ts/utils';
 
+import type { FakeResources } from '../account';
 import { Account } from '../account';
 import {
   transactionRequestify,
@@ -195,6 +196,20 @@ export class Predicate<TInputData extends InputValue[]> extends Account {
     }));
   }
 
+  /**
+   * Generates an array of fake resources based on the provided coins.
+   *
+   * @param coins - An array of `FakeResources` objects representing the coins.
+   * @returns An array of `Resource` objects with generated properties.
+   */
+  generateFakeResources(coins: FakeResources[]): Array<Resource> {
+    return super.generateFakeResources(coins).map((coin) => ({
+      ...coin,
+      predicate: hexlify(this.bytes),
+      predicateData: hexlify(this.getPredicateData()),
+    }));
+  }
+
   /**
    * Sets the configurable constants for the predicate.
    *

packages/fuel-gauge/src/predicate/predicate-general.test.ts

@@ -0,0 +1,71 @@
+import { ASSET_A, ASSET_B } from '@fuel-ts/utils/test-utils';
+import type { BN, FakeResources } from 'fuels';
+import {
+  Address,
+  FUEL_NETWORK_URL,
+  Predicate,
+  Provider,
+  ScriptTransactionRequest,
+  bn,
+} from 'fuels';
+
+import { FuelGaugeProjectsEnum, getFuelGaugeForcProject } from '../../test/fixtures';
+
+/**
+ * @group node
+ */
+describe('Predicate', () => {
+  it('can generate and use fake predicate coins', async () => {
+    const provider = await Provider.create(FUEL_NETWORK_URL);
+    const baseAssetId = provider.getBaseAssetId();
+    const { binHexlified, abiContents } = getFuelGaugeForcProject(
+      FuelGaugeProjectsEnum.PREDICATE_SUM
+    );
+
+    const amount1 = bn(100_000);
+    const amount2 = bn(200_000);
+    const amount3 = bn(300_000);
+
+    const fakeCoinsConfig: FakeResources[] = [
+      { amount: amount1, assetId: baseAssetId },
+      { amount: amount2, assetId: ASSET_A },
+      { amount: amount3, assetId: ASSET_B },
+    ];
+
+    const value2 = bn(200);
+    const value1 = bn(100);
+
+    const predicate = new Predicate<[BN, BN]>({
+      bytecode: binHexlified,
+      abi: abiContents,
+      provider,
+      inputData: [value1, value2],
+    });
+
+    const fakeCoins = predicate.generateFakeResources(fakeCoinsConfig);
+
+    let request = new ScriptTransactionRequest({
+      gasLimit: bn(1500),
+      maxFee: bn(1700),
+    });
+
+    fakeCoins.forEach((coin) => {
+      expect(coin.predicate).toBeDefined();
+      expect(coin.predicateData).toBeDefined();
+    });
+
+    request.addResources(fakeCoins);
+    request.addCoinOutput(Address.fromRandom(), amount1.div(3), baseAssetId);
+    request.addCoinOutput(Address.fromRandom(), amount2, ASSET_A);
+    request.addCoinOutput(Address.fromRandom(), amount3, ASSET_B);
+
+    request = await provider.estimatePredicates(request);
+
+    const { dryRunStatus } = await provider.call(request, {
+      utxoValidation: false,
+      estimateTxDependencies: false,
+    });
+
+    expect(dryRunStatus?.type).toBe('DryRunSuccessStatus');
+  });
+});