feat: implement FTI

.changeset/spicy-ghosts-call.md

@@ -0,0 +1,6 @@
+---
+'@fuel-bridge/solidity-contracts': minor
+'@fuel-bridge/test-utils': minor
+---
+
+Add Forced Transaction Inclusion (FTI) to FuelMessagePortal

docker/fuel-core/Dockerfile

@@ -1,8 +1,9 @@
-# IMPORTANT! When upgrading fuel-core version,
-# Make sure to check
+# IMPORTANT!
+# Make sure to check:
 # https://github.com/FuelLabs/chain-configuration/tree/master/upgradelog/ignition
 # and apply the latest state_transition_function and consensus_parameter
-FROM ghcr.io/fuellabs/fuel-core:v0.28.0
+# when upgrading fuel-core
+FROM ghcr.io/fuellabs/fuel-core:v0.31.0
 
 ARG FUEL_IP=0.0.0.0
 ARG FUEL_PORT=4001
@@ -27,7 +28,7 @@ RUN cp -R /chain-configuration/local/* ./
 # Copy the testnet consensus parameters and state transition bytecode
 RUN cp /chain-configuration/upgradelog/ignition/consensus_parameters/3.json \
     ./latest_consensus_parameters.json
-RUN cp /chain-configuration/upgradelog/ignition/state_transition_function/2.wasm \
+RUN cp /chain-configuration/upgradelog/ignition/state_transition_function/5.wasm \
     ./state_transition_bytecode.wasm
 
 # update local state_config with custom genesis coins config

packages/integration-tests/tests/fti.ts

@@ -0,0 +1,225 @@
+import type { TestEnvironment } from '@fuel-bridge/test-utils';
+import { setupEnvironment, waitForTransaction } from '@fuel-bridge/test-utils';
+import chai from 'chai';
+import { hexlify, solidityPacked } from 'ethers';
+import { sha256, transactionRequestify } from 'fuels';
+import type { WalletUnlocked as FuelWallet, BN } from 'fuels';
+
+const { expect } = chai;
+
+const MAX_GAS = 10000000n;
+
+describe('Forced Transaction Inclusion', async function () {
+  // Timeout 6 minutes
+  const DEFAULT_TIMEOUT_MS: number = 400_000;
+  let BASE_ASSET_ID: string;
+  let CHAIN_ID: number;
+
+  let env: TestEnvironment;
+
+  // override the default test timeout of 2000ms
+  this.timeout(DEFAULT_TIMEOUT_MS);
+
+  before(async () => {
+    env = await setupEnvironment({});
+    BASE_ASSET_ID = env.fuel.provider.getBaseAssetId();
+    CHAIN_ID = env.fuel.provider.getChainId();
+  });
+
+  describe('Send a transaction through Ethereum', async () => {
+    const NUM_ETH = '0.1';
+    let ethSender: any;
+    let fuelSender: FuelWallet;
+    let fuelReceiver: FuelWallet;
+    let fuelSenderBalance: BN;
+    let fuelReceiverBalance: BN;
+
+    before(async () => {
+      ethSender;
+      fuelSender = env.fuel.deployer;
+      fuelReceiver = env.fuel.signers[1];
+      fuelSenderBalance = await fuelSender.getBalance(BASE_ASSET_ID);
+      fuelReceiverBalance = await fuelReceiver.getBalance(BASE_ASSET_ID);
+    });
+
+    it('allows to send transactions', async () => {
+      const transferRequest = await fuelSender.createTransfer(
+        fuelReceiver.address,
+        fuelSenderBalance.div(10),
+        BASE_ASSET_ID
+      );
+
+      const transactionRequest = transactionRequestify(transferRequest);
+      await env.fuel.provider.estimateTxDependencies(transactionRequest);
+
+      const signature = await fuelSender.signTransaction(transactionRequest);
+      transactionRequest.updateWitnessByOwner(fuelSender.address, signature);
+
+      const fuelSerializedTx = hexlify(transactionRequest.toTransactionBytes());
+
+      const gasPrice = await env.eth.fuelMessagePortal.MIN_GAS_PRICE();
+      const expectedFee = gasPrice * MAX_GAS;
+
+      const ethTx = await env.eth.fuelMessagePortal.sendTransaction(
+        MAX_GAS,
+        fuelSerializedTx,
+        { value: expectedFee }
+      );
+
+      const { blockNumber } = await ethTx.wait();
+
+      const [event] = await env.eth.fuelMessagePortal.queryFilter(
+        env.eth.fuelMessagePortal.filters.Transaction,
+        blockNumber,
+        blockNumber
+      );
+
+      expect(event.args.canonically_serialized_tx).to.be.equal(
+        fuelSerializedTx
+      );
+
+      const payload = solidityPacked(
+        ['uint256', 'uint64', 'bytes'],
+        [
+          event.args.nonce,
+          event.args.max_gas,
+          event.args.canonically_serialized_tx,
+        ]
+      );
+      const relayedTxId = sha256(payload);
+      const fuelTxId = transactionRequest.getTransactionId(CHAIN_ID);
+
+      const { response, error } = await waitForTransaction(
+        fuelTxId,
+        env.fuel.provider,
+        {
+          relayedTxId,
+        }
+      );
+
+      if (error) {
+        throw new Error(error);
+      }
+
+      const txResult = await response.waitForResult();
+
+      expect(txResult.status).to.equal('success');
+    });
+
+    it('rejects transactions without signatures', async () => {
+      const transferRequest = await fuelSender.createTransfer(
+        fuelReceiver.address,
+        fuelSenderBalance.div(10),
+        BASE_ASSET_ID
+      );
+
+      const transactionRequest = transactionRequestify(transferRequest);
+      await env.fuel.provider.estimateTxDependencies(transactionRequest);
+
+      const fuelSerializedTx = hexlify(transactionRequest.toTransactionBytes());
+
+      const gasPrice = await env.eth.fuelMessagePortal.MIN_GAS_PRICE();
+      const expectedFee = gasPrice * MAX_GAS;
+
+      const ethTx = await env.eth.fuelMessagePortal.sendTransaction(
+        MAX_GAS,
+        fuelSerializedTx,
+        { value: expectedFee }
+      );
+
+      const { blockNumber } = await ethTx.wait();
+
+      const [event] = await env.eth.fuelMessagePortal.queryFilter(
+        env.eth.fuelMessagePortal.filters.Transaction,
+        blockNumber,
+        blockNumber
+      );
+
+      expect(event.args.canonically_serialized_tx).to.be.equal(
+        fuelSerializedTx
+      );
+
+      const payload = solidityPacked(
+        ['uint256', 'uint64', 'bytes'],
+        [
+          event.args.nonce,
+          event.args.max_gas,
+          event.args.canonically_serialized_tx,
+        ]
+      );
+      const relayedTxId = sha256(payload);
+      const fuelTxId = transactionRequest.getTransactionId(CHAIN_ID);
+
+      const { response, error } = await waitForTransaction(
+        fuelTxId,
+        env.fuel.provider,
+        {
+          relayedTxId,
+        }
+      );
+
+      expect(response).to.be.null;
+      expect(error).to.contain('InvalidSignature');
+    });
+
+    it('rejects transactions without enough gas', async () => {
+      const transferRequest = await fuelSender.createTransfer(
+        fuelReceiver.address,
+        fuelSenderBalance.div(10),
+        BASE_ASSET_ID
+      );
+
+      const transactionRequest = transactionRequestify(transferRequest);
+      await env.fuel.provider.estimateTxDependencies(transactionRequest);
+
+      const signature = await fuelSender.signTransaction(transactionRequest);
+      transactionRequest.updateWitnessByOwner(fuelSender.address, signature);
+
+      const fuelSerializedTx = hexlify(transactionRequest.toTransactionBytes());
+
+      const gasPrice = await env.eth.fuelMessagePortal.MIN_GAS_PRICE();
+      const minGasPerTx = await env.eth.fuelMessagePortal.MIN_GAS_PER_TX();
+      const expectedFee = gasPrice * minGasPerTx;
+
+      const ethTx = await env.eth.fuelMessagePortal.sendTransaction(
+        minGasPerTx,
+        fuelSerializedTx,
+        { value: expectedFee }
+      );
+
+      const { blockNumber } = await ethTx.wait();
+
+      const [event] = await env.eth.fuelMessagePortal.queryFilter(
+        env.eth.fuelMessagePortal.filters.Transaction,
+        blockNumber,
+        blockNumber
+      );
+
+      expect(event.args.canonically_serialized_tx).to.be.equal(
+        fuelSerializedTx
+      );
+
+      const payload = solidityPacked(
+        ['uint256', 'uint64', 'bytes'],
+        [
+          event.args.nonce,
+          event.args.max_gas,
+          event.args.canonically_serialized_tx,
+        ]
+      );
+      const relayedTxId = sha256(payload);
+      const fuelTxId = transactionRequest.getTransactionId(CHAIN_ID);
+
+      const { response, error } = await waitForTransaction(
+        fuelTxId,
+        env.fuel.provider,
+        {
+          relayedTxId,
+        }
+      );
+
+      expect(response).to.be.null;
+      expect(error).to.contain('Insufficient');
+    });
+  });
+});