chore: run benchmarking utility in devnet environment

.changeset/ninety-carpets-watch.md

@@ -0,0 +1,5 @@
+---
+"@internal/benchmarks": minor
+---
+
+chore: run benchmarking utility in devnet environment

.github/workflows/bench-testnet.yaml

@@ -0,0 +1,32 @@
+name: "Bench Devnet"
+
+on:
+  # Remove this before merging, we only want devnet tests on master
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+      - release/*
+
+jobs:
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: CI Setup
+        uses: ./.github/actions/test-setup
+
+      - name: Pretest
+        run: pnpm pretest
+
+      - name: Run Node benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+          run: pnpm bench:node
+          token: ${{ secrets.CODSPEED_TOKEN }}
+        env:
+          DEVNET_WALLET_PVT_KEY: ${{ secrets.DEVNET_WALLET_PVT_KEY }}

.github/workflows/bench.yml

@@ -1,9 +1,11 @@
 name: Benchmarks
 on:
   pull_request:
-  push:
     branches:
       - master
+  push:
+    branches-ignore:
+      - master
 
 jobs:
   benchmarks:

internal/benchmarks/package.json

@@ -11,7 +11,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "fuels": "workspace:*"
+    "fuels": "workspace:*",
+    "@internal/utils": "workspace:*"
   },
   "version": "1.0.1"
 }

internal/benchmarks/src/config.ts

@@ -0,0 +1,11 @@
+import { DEVNET_NETWORK_URL } from '@internal/utils';
+import { TransactionType } from 'fuels';
+
+export const DEVNET_CONFIG = {
+  networkUrl: DEVNET_NETWORK_URL,
+  faucetUrl: `https://faucet-devnet.fuel.network/`,
+  txIds: {
+    [TransactionType.Upgrade]: '0xe2c03044fe708e9b112027881baf9f892e6b64a630a629998922c1cab918c094',
+    [TransactionType.Upload]: '0x94bc2a189b8211796c8fe5b9c6b67624fe97d2007e104bf1b30739944f43bd73',
+  },
+};

internal/benchmarks/src/contract-interaction.bench.ts

@@ -1,12 +1,13 @@
 /* eslint-disable import/no-extraneous-dependencies */
 
-import type { WalletUnlocked } from 'fuels';
-import { bn } from 'fuels';
+import { WalletUnlocked, bn, Provider } from 'fuels';
 import { launchTestNode, TestAssetId } from 'fuels/test-utils';
 import { bench } from 'vitest';
 
 import type { CounterContract, CallTestContract } from '../test/typegen/contracts';
 import { CounterContractFactory, CallTestContractFactory } from '../test/typegen/contracts';
+
+import { DEVNET_CONFIG } from './config';
 /**
  * @group node
  * @group browser
@@ -16,20 +17,32 @@ describe('Contract Interaction Benchmarks', () => {
   let callTestContract: CallTestContract;
   let wallet: WalletUnlocked;
   let cleanup: () => void;
-  beforeEach(async () => {
-    const launched = await launchTestNode({
-      contractsConfigs: [{ factory: CounterContractFactory }, { factory: CallTestContractFactory }],
+
+  if (process.env.DEVNET_WALLET_PVT_KEY !== undefined) {
+    beforeAll(async () => {
+      const { networkUrl } = DEVNET_CONFIG;
+      const provider = await Provider.create(networkUrl);
+      wallet = new WalletUnlocked(process.env.DEVNET_WALLET_PVT_KEY as string, provider);
     });
+  } else {
+    beforeEach(async () => {
+      const launched = await launchTestNode({
+        contractsConfigs: [
+          { factory: CounterContractFactory },
+          { factory: CallTestContractFactory },
+        ],
+      });
 
-    cleanup = launched.cleanup;
-    contract = launched.contracts[0];
-    callTestContract = launched.contracts[1];
-    wallet = launched.wallets[0];
-  });
+      cleanup = launched.cleanup;
+      contract = launched.contracts[0];
+      callTestContract = launched.contracts[1];
+      wallet = launched.wallets[0];
+    });
 
-  afterEach(() => {
-    cleanup();
-  });
+    afterEach(() => {
+      cleanup();
+    });
+  }
 
   bench('should successfully execute a contract read function', async () => {
     const tx = await contract.functions.get_count().call();

internal/benchmarks/src/cost-estimation.bench.ts

@@ -1,134 +1,172 @@
 /* eslint-disable import/no-extraneous-dependencies */
 
-import type { TransferParams, Provider } from 'fuels';
-import { ScriptTransactionRequest, Wallet } from 'fuels';
+import type { TransferParams, WalletUnlocked } from 'fuels';
+import { Wallet, Provider, ScriptTransactionRequest } from 'fuels';
 import { launchTestNode, TestAssetId } from 'fuels/test-utils';
 import { bench } from 'vitest';
 
 import type { CallTestContract } from '../test/typegen/contracts';
 import { CallTestContractFactory } from '../test/typegen/contracts';
 
+import { DEVNET_CONFIG } from './config';
+
 /**
  * @group node
  * @group browser
  */
 describe('Cost Estimation Benchmarks', () => {
   let contract: CallTestContract;
   let provider: Provider;
+  let request: ScriptTransactionRequest;
+  let recipient: WalletUnlocked;
+  let receiver1: WalletUnlocked;
+  let receiver2: WalletUnlocked;
+  let receiver3: WalletUnlocked;
+  let sender: WalletUnlocked;
+
   let cleanup: () => void;
-  beforeEach(async () => {
-    const launched = await launchTestNode({
-      contractsConfigs: [{ factory: CallTestContractFactory }],
+
+  const setup = (testProvider: Provider) => {
+    request = new ScriptTransactionRequest({ gasLimit: 1000000 });
+
+    recipient = Wallet.generate({
+      provider: testProvider,
+    });
+    receiver1 = Wallet.generate({
+      provider: testProvider,
+    });
+    receiver2 = Wallet.generate({
+      provider: testProvider,
+    });
+    receiver3 = Wallet.generate({
+      provider: testProvider,
     });
+    sender = Wallet.fromPrivateKey(
+      '0x30bb0bc68f5d2ec3b523cee5a65503031b40679d9c72280cd8088c2cfbc34e38',
+      testProvider
+    );
+  };
 
-    cleanup = launched.cleanup;
-    contract = launched.contracts[0];
-    provider = contract.provider;
-  });
+  if (process.env.DEVNET_WALLET_PVT_KEY !== undefined) {
+    beforeAll(async () => {
+      const { networkUrl } = DEVNET_CONFIG;
+      provider = await Provider.create(networkUrl);
 
-  afterEach(() => {
-    cleanup();
-  });
+      setup(provider);
+    });
+  } else {
+    beforeEach(async () => {
+      const launched = await launchTestNode({
+        contractsConfigs: [{ factory: CallTestContractFactory }],
+      });
+
+      cleanup = launched.cleanup;
+      contract = launched.contracts[0];
+      provider = contract.provider;
+
+      setup(provider);
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+  }
 
   bench(
-    'should successfully get transaction cost estimate for a single contract call',
+    'should successfully get transaction cost estimate for a single contract call done 10 times',
     async () => {
-      const cost = await contract.functions
-        .return_context_amount()
-        .callParams({
+      for (let i = 0; i < 10; i++) {
+        const cost = await contract.functions
+          .return_context_amount()
+          .callParams({
+            forward: [100, contract.provider.getBaseAssetId()],
+          })
+          .getTransactionCost();
+
+        expect(cost.minFee).toBeDefined();
+        expect(cost.maxFee).toBeDefined();
+        expect(cost.gasPrice).toBeDefined();
+        expect(cost.gasUsed).toBeDefined();
+        expect(cost.gasPrice).toBeDefined();
+      }
+    }
+  );
+
+  bench('should successfully get transaction cost estimate for multi contract calls', async () => {
+    for (let i = 0; i < 10; i++) {
+      const invocationScope = contract.multiCall([
+        contract.functions.return_context_amount().callParams({
           forward: [100, contract.provider.getBaseAssetId()],
-        })
-        .getTransactionCost();
+        }),
+        contract.functions.return_context_amount().callParams({
+          forward: [200, TestAssetId.A.value],
+        }),
+      ]);
+
+      const cost = await invocationScope.getTransactionCost();
 
       expect(cost.minFee).toBeDefined();
       expect(cost.maxFee).toBeDefined();
       expect(cost.gasPrice).toBeDefined();
       expect(cost.gasUsed).toBeDefined();
       expect(cost.gasPrice).toBeDefined();
     }
-  );
-
-  bench('should successfully get transaction cost estimate for multi contract calls', async () => {
-    const invocationScope = contract.multiCall([
-      contract.functions.return_context_amount().callParams({
-        forward: [100, contract.provider.getBaseAssetId()],
-      }),
-      contract.functions.return_context_amount().callParams({
-        forward: [200, TestAssetId.A.value],
-      }),
-    ]);
-
-    const cost = await invocationScope.getTransactionCost();
-
-    expect(cost.minFee).toBeDefined();
-    expect(cost.maxFee).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
-    expect(cost.gasUsed).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
   });
 
   bench('should successfully get transaction cost estimate for a single transfer', async () => {
-    const request = new ScriptTransactionRequest({ gasLimit: 1000000 });
+    for (let i = 0; i < 10; i++) {
+      request.addCoinOutput(recipient.address, 10, provider.getBaseAssetId());
 
-    const recipient = Wallet.generate({
-      provider,
-    });
-    const sender = Wallet.fromPrivateKey(
-      '0x30bb0bc68f5d2ec3b523cee5a65503031b40679d9c72280cd8088c2cfbc34e38',
-      provider
-    );
-
-    request.addCoinOutput(recipient.address, 10, provider.getBaseAssetId());
+      const cost = await sender.getTransactionCost(request);
 
-    const cost = await sender.getTransactionCost(request);
-
-    expect(cost.minFee).toBeDefined();
-    expect(cost.maxFee).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
-    expect(cost.gasUsed).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
+      expect(cost.minFee).toBeDefined();
+      expect(cost.maxFee).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+      expect(cost.gasUsed).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+    }
   });
 
   bench('should successfully get transaction cost estimate for a batch transfer', async () => {
-    const receiver1 = Wallet.generate({ provider });
-    const receiver2 = Wallet.generate({ provider });
-    const receiver3 = Wallet.generate({ provider });
-
-    const amountToTransfer1 = 989;
-    const amountToTransfer2 = 699;
-    const amountToTransfer3 = 122;
-
-    const transferParams: TransferParams[] = [
-      {
-        destination: receiver1.address,
-        amount: amountToTransfer1,
-        assetId: provider.getBaseAssetId(),
-      },
-      { destination: receiver2.address, amount: amountToTransfer2, assetId: TestAssetId.A.value },
-      { destination: receiver3.address, amount: amountToTransfer3, assetId: TestAssetId.B.value },
-    ];
-
-    const cost = await contract.functions
-      .sum(40, 50)
-      .addBatchTransfer(transferParams)
-      .getTransactionCost();
-
-    expect(cost.minFee).toBeDefined();
-    expect(cost.maxFee).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
-    expect(cost.gasUsed).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
+    for (let i = 0; i < 10; i++) {
+      const amountToTransfer1 = 989;
+      const amountToTransfer2 = 699;
+      const amountToTransfer3 = 122;
+
+      const transferParams: TransferParams[] = [
+        {
+          destination: receiver1.address,
+          amount: amountToTransfer1,
+          assetId: provider.getBaseAssetId(),
+        },
+        { destination: receiver2.address, amount: amountToTransfer2, assetId: TestAssetId.A.value },
+        { destination: receiver3.address, amount: amountToTransfer3, assetId: TestAssetId.B.value },
+      ];
+
+      const cost = await contract.functions
+        .sum(40, 50)
+        .addBatchTransfer(transferParams)
+        .getTransactionCost();
+
+      expect(cost.minFee).toBeDefined();
+      expect(cost.maxFee).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+      expect(cost.gasUsed).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+    }
   });
 
-  it('should successfully get transaction cost estimate for a mint', async () => {
-    const subId = '0x4a778acfad1abc155a009dc976d2cf0db6197d3d360194d74b1fb92b96986b00';
+  it('should successfully get transaction cost estimate for a mint 10 times', async () => {
+    for (let i = 0; i < 10; i++) {
+      const subId = '0x4a778acfad1abc155a009dc976d2cf0db6197d3d360194d74b1fb92b96986b00';
 
-    const cost = await contract.functions.mint_coins(subId, 1_000).getTransactionCost();
+      const cost = await contract.functions.mint_coins(subId, 1_000).getTransactionCost();
 
-    expect(cost.minFee).toBeDefined();
-    expect(cost.maxFee).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
-    expect(cost.gasUsed).toBeDefined();
-    expect(cost.gasPrice).toBeDefined();
+      expect(cost.minFee).toBeDefined();
+      expect(cost.maxFee).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+      expect(cost.gasUsed).toBeDefined();
+      expect(cost.gasPrice).toBeDefined();
+    }
   });
 });