ci: add initial benchmark infrastructure

.github/workflows/bench.yml

@@ -0,0 +1,23 @@
+name: Benchmarks
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: CI Setup
+        uses: ./.github/actions/test-setup
+
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+          run: pnpm exec vitest bench
+          token: ${{ secrets.CODSPEED_TOKEN }}

.gitignore

@@ -24,6 +24,7 @@ lib-cov
 *.pid
 *.gz
 *.swp
+*.0x/*
 
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
@@ -144,6 +145,10 @@ Forc.lock
 **/out/release
 **/test-predicate-*/index.ts
 
+## Ignore perf test files
+*clinic*
+.clinic/*
+
 # Ignore typegen test files
 **/test/typegen
 

internal/benchmarks/.gitignore

@@ -0,0 +1 @@
+test/fixtures/forc-projects/**/index.ts

internal/benchmarks/README.md

@@ -0,0 +1 @@
+A package for running benchmarks.

internal/benchmarks/fuels.config.ts

@@ -0,0 +1,9 @@
+import { createConfig } from 'fuels';
+
+export default createConfig({
+  workspace: './test/fixtures/forc-projects',
+  output: './test/typegen',
+  forcBuildFlags: ['--release'],
+  forcPath: 'fuels-forc',
+  fuelCorePath: 'fuels-core',
+});

internal/benchmarks/package.json

@@ -0,0 +1,19 @@
+{
+  "private": true,
+  "name": "@internal/benchmarks",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "type:check": "tsc --noEmit",
+    "pretest": "run-s build:forc type:check",
+    "build:forc": "pnpm fuels build"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@fuel-ts/crypto": "workspace:*",
+    "@fuel-ts/account": "workspace:*",
+    "fuels": "workspace:*"
+  },
+  "version": "1.0.0"
+}

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

@@ -0,0 +1,139 @@
+/* eslint-disable import/no-extraneous-dependencies */
+
+import type { TransferParams } from 'fuels';
+import { ScriptTransactionRequest, Wallet } from 'fuels';
+import { launchTestNode, TestAssetId } from 'fuels/test-utils';
+import { bench } from 'vitest';
+
+import { CallTestContractFactory } from '../test/typegen/contracts';
+
+/**
+ * @group node
+ */
+describe('Cost Estimation Benchmarks', () => {
+  bench(
+    'should successfully get transaction cost estimate for a single contract call',
+    async () => {
+      using launched = await launchTestNode({
+        contractsConfigs: [
+          {
+            factory: CallTestContractFactory,
+          },
+        ],
+      });
+
+      const {
+        contracts: [contract],
+      } = launched;
+
+      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 () => {
+    using launched = await launchTestNode({
+      contractsConfigs: [{ factory: CallTestContractFactory }],
+    });
+
+    const {
+      contracts: [contract],
+    } = launched;
+
+    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 () => {
+    using launched = await launchTestNode({
+      // Only deploying the contract so that we have the same config for both benchmarks
+      contractsConfigs: [{ factory: CallTestContractFactory }],
+    });
+
+    const { provider } = launched;
+
+    const request = new ScriptTransactionRequest({ gasLimit: 1000000 });
+
+    const recipient = Wallet.generate({
+      provider,
+    });
+    const sender = Wallet.fromPrivateKey(
+      '0x30bb0bc68f5d2ec3b523cee5a65503031b40679d9c72280cd8088c2cfbc34e38',
+      provider
+    );
+
+    request.addCoinOutput(recipient.address, 10, provider.getBaseAssetId());
+
+    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();
+  });
+
+  bench('should successfully get transaction cost estimate for a batch transfer', async () => {
+    using launched = await launchTestNode({
+      contractsConfigs: [{ factory: CallTestContractFactory }],
+    });
+
+    const {
+      provider,
+      contracts: [contract],
+    } = launched;
+
+    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();
+  });
+});

internal/benchmarks/src/crypto.bench.ts

@@ -0,0 +1,64 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import type { Keystore } from '@fuel-ts/crypto';
+import { bufferFromString, pbkdf2, computeHmac, encrypt, decrypt } from '@fuel-ts/crypto';
+import { bench } from 'vitest';
+
+/**
+ * @group node
+ * @group browser
+ */
+describe('crypto bench', () => {
+  bench(
+    'should correctly convert string to Uint8Array with base64 encoding in a node environment',
+    () => {
+      const string = 'aGVsbG8='; // "hello" in Base64
+      bufferFromString(string, 'base64');
+    }
+  );
+
+  bench('should compute the PBKDF2 hash', () => {
+    const passwordBuffer = bufferFromString(String('password123').normalize('NFKC'), 'utf-8');
+    const saltBuffer = bufferFromString(String('salt456').normalize('NFKC'), 'utf-8');
+    const iterations = 1000;
+    const keylen = 32;
+    const algo = 'sha256';
+
+    pbkdf2(passwordBuffer, saltBuffer, iterations, keylen, algo);
+  });
+
+  bench('should compute HMAC correctly', () => {
+    const key = '0x0102030405060708090a0b0c0d0e0f10';
+    const data = '0x11121314151617181920212223242526';
+    const sha256Length = 64;
+    const sha512Length = 128;
+    const prefix = '0x';
+
+    expect(computeHmac('sha256', key, data).length).toBe(sha256Length + prefix.length);
+    expect(computeHmac('sha512', key, data).length).toBe(sha512Length + prefix.length);
+  });
+
+  bench('Encrypt via aes-ctr', async () => {
+    const password = '0b540281-f87b-49ca-be37-2264c7f260f7';
+    const data = {
+      name: 'test',
+    };
+
+    const encryptedResult = await encrypt(password, data);
+    expect(encryptedResult.data).toBeTruthy();
+    expect(encryptedResult.iv).toBeTruthy();
+    expect(encryptedResult.salt).toBeTruthy();
+  });
+
+  bench('Decrypt via aes-ctr', async () => {
+    const password = '0b540281-f87b-49ca-be37-2264c7f260f7';
+    const data = {
+      name: 'test',
+    };
+    const encryptedResult: Keystore = {
+      data: 'vj1/JyHR+NiIaWXTpl5T',
+      iv: '0/lqnRVK5HE/5b1cQAHfqg==',
+      salt: 'nHdHXW2EmOEagAH2UUDYMRNhd7LJ5XLIcZoVQZMPSlU=',
+    };
+    await decrypt(password, encryptedResult);
+  });
+});

internal/benchmarks/src/transaction-results.bench.ts

@@ -0,0 +1,110 @@
+/* eslint-disable import/no-extraneous-dependencies */
+
+import { Wallet } from 'fuels';
+import type { TransferParams } from 'fuels';
+import { launchTestNode, TestAssetId } from 'fuels/test-utils';
+import { bench } from 'vitest';
+
+/**
+ * @group node
+ */
+describe('Transaction Submission Benchmarks', () => {
+  bench('should successfully transfer a single asset between wallets', async () => {
+    using launched = await launchTestNode();
+
+    const {
+      provider,
+      wallets: [walletA],
+    } = launched;
+
+    const receiver = Wallet.generate({ provider });
+
+    const tx = await walletA.transfer(receiver.address, 100, provider.getBaseAssetId());
+
+    const { isStatusSuccess } = await tx.waitForResult();
+
+    expect(isStatusSuccess).toBeTruthy();
+  });
+
+  bench('should successfully conduct a custom transfer between wallets', async () => {
+    using launched = await launchTestNode();
+
+    const {
+      provider,
+      wallets: [wallet],
+    } = launched;
+
+    const receiver = Wallet.generate({ provider });
+
+    const txParams = {
+      tip: 4,
+      witnessLimit: 800,
+      maxFee: 70_000,
+    };
+
+    const pendingTx = await wallet.transfer(
+      receiver.address,
+      500,
+      provider.getBaseAssetId(),
+      txParams
+    );
+
+    const { transaction } = await pendingTx.waitForResult();
+
+    expect(transaction).toBeDefined();
+  });
+
+  bench('should successfully perform a batch transfer', async () => {
+    using launched = await launchTestNode();
+
+    const {
+      provider,
+      wallets: [wallet],
+    } = launched;
+
+    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 tx = await wallet.batchTransfer(transferParams);
+
+    const { isStatusSuccess } = await tx.waitForResult();
+
+    expect(isStatusSuccess).toBeTruthy();
+  });
+
+  bench('should successfully withdraw to the base layer', async () => {
+    using launched = await launchTestNode();
+
+    const {
+      provider,
+      wallets: [wallet],
+    } = launched;
+
+    const receiver = Wallet.generate({ provider });
+
+    const txParams = {
+      witnessLimit: 800,
+      maxFee: 100_000,
+    };
+
+    const pendingTx = await wallet.withdrawToBaseLayer(receiver.address, 500, txParams);
+    const { transaction } = await pendingTx.waitForResult();
+
+    expect(transaction).toBeDefined();
+  });
+});