web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/account/utils/draft-ERC7579Utils.test.js

@@ -0,0 +1,399 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const {
+  CALL_TYPE_CALL,
+  CALL_TYPE_BATCH,
+  CALL_TYPE_DELEGATE,
+  EXEC_TYPE_DEFAULT,
+  EXEC_TYPE_TRY,
+  encodeSingle,
+  encodeBatch,
+  encodeDelegate,
+  encodeMode,
+} = require('../../helpers/erc7579');
+const { selector } = require('../../helpers/methods');
+
+const coder = ethers.AbiCoder.defaultAbiCoder();
+
+const fixture = async () => {
+  const [sender] = await ethers.getSigners();
+  const utils = await ethers.deployContract('$ERC7579Utils', { value: ethers.parseEther('1') });
+  const utilsGlobal = await ethers.deployContract('$ERC7579UtilsGlobalMock');
+  const target = await ethers.deployContract('CallReceiverMock');
+  const anotherTarget = await ethers.deployContract('CallReceiverMock');
+  return { utils, utilsGlobal, target, anotherTarget, sender };
+};
+
+describe('ERC7579Utils', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('constants', async function () {
+    await expect(this.utils.$CALLTYPE_SINGLE()).to.eventually.equal(CALL_TYPE_CALL);
+    await expect(this.utils.$CALLTYPE_BATCH()).to.eventually.equal(CALL_TYPE_BATCH);
+    await expect(this.utils.$CALLTYPE_DELEGATECALL()).to.eventually.equal(CALL_TYPE_DELEGATE);
+    await expect(this.utils.$EXECTYPE_DEFAULT()).to.eventually.equal(EXEC_TYPE_DEFAULT);
+    await expect(this.utils.$EXECTYPE_TRY()).to.eventually.equal(EXEC_TYPE_TRY);
+  });
+
+  describe('execSingle', function () {
+    it('calls the target with value', async function () {
+      const value = 0x012;
+      const data = encodeSingle(this.target, value, this.target.interface.encodeFunctionData('mockFunction'));
+
+      await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT)).to.emit(this.target, 'MockFunctionCalled');
+
+      await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value);
+    });
+
+    it('calls the target with value and args', async function () {
+      const value = 0x432;
+      const data = encodeSingle(
+        this.target,
+        value,
+        this.target.interface.encodeFunctionData('mockFunctionWithArgs', [42, '0x1234']),
+      );
+
+      await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.target, 'MockFunctionCalledWithArgs')
+        .withArgs(42, '0x1234');
+
+      await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value);
+    });
+
+    it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () {
+      const data = encodeSingle(
+        ethers.ZeroAddress, // address(0)
+        0,
+        this.utils.interface.encodeFunctionData('$CALLTYPE_SINGLE', []),
+      );
+
+      await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.utils, 'return$execSingle')
+        .withArgs([ethers.zeroPadBytes(CALL_TYPE_CALL, 32)]);
+    });
+
+    it('reverts when target reverts in default ExecType', async function () {
+      const value = 0x012;
+      const data = encodeSingle(
+        this.target,
+        value,
+        this.target.interface.encodeFunctionData('mockFunctionRevertsReason'),
+      );
+
+      await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT)).to.be.revertedWith('CallReceiverMock: reverting');
+    });
+
+    it('emits ERC7579TryExecuteFail event when target reverts in try ExecType', async function () {
+      const value = 0x012;
+      const data = encodeSingle(
+        this.target,
+        value,
+        this.target.interface.encodeFunctionData('mockFunctionRevertsReason'),
+      );
+
+      await expect(this.utils.$execSingle(data, EXEC_TYPE_TRY))
+        .to.emit(this.utils, 'ERC7579TryExecuteFail')
+        .withArgs(
+          CALL_TYPE_CALL,
+          ethers.solidityPacked(
+            ['bytes4', 'bytes'],
+            [selector('Error(string)'), coder.encode(['string'], ['CallReceiverMock: reverting'])],
+          ),
+        );
+    });
+
+    it('reverts with an invalid exec type', async function () {
+      const value = 0x012;
+      const data = encodeSingle(this.target, value, this.target.interface.encodeFunctionData('mockFunction'));
+
+      await expect(this.utils.$execSingle(data, '0x03'))
+        .to.be.revertedWithCustomError(this.utils, 'ERC7579UnsupportedExecType')
+        .withArgs('0x03');
+    });
+  });
+
+  describe('execBatch', function () {
+    it('calls the targets with value', async function () {
+      const value1 = 0x012;
+      const value2 = 0x234;
+      const data = encodeBatch(
+        [this.target, value1, this.target.interface.encodeFunctionData('mockFunction')],
+        [this.anotherTarget, value2, this.anotherTarget.interface.encodeFunctionData('mockFunction')],
+      );
+
+      await expect(this.utils.$execBatch(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.target, 'MockFunctionCalled')
+        .to.emit(this.anotherTarget, 'MockFunctionCalled');
+
+      await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1);
+      await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2);
+    });
+
+    it('calls the targets with value and args', async function () {
+      const value1 = 0x012;
+      const value2 = 0x234;
+      const data = encodeBatch(
+        [this.target, value1, this.target.interface.encodeFunctionData('mockFunctionWithArgs', [42, '0x1234'])],
+        [
+          this.anotherTarget,
+          value2,
+          this.anotherTarget.interface.encodeFunctionData('mockFunctionWithArgs', [42, '0x1234']),
+        ],
+      );
+
+      await expect(this.utils.$execBatch(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.target, 'MockFunctionCalledWithArgs')
+        .to.emit(this.anotherTarget, 'MockFunctionCalledWithArgs');
+
+      await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1);
+      await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2);
+    });
+
+    it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () {
+      const data = encodeBatch(
+        [ethers.ZeroAddress, 0, this.utils.interface.encodeFunctionData('$CALLTYPE_SINGLE', [])],
+        [ethers.ZeroAddress, 0, this.utils.interface.encodeFunctionData('$CALLTYPE_BATCH', [])],
+      );
+
+      await expect(this.utils.$execBatch(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.utils, 'return$execBatch')
+        .withArgs([ethers.zeroPadBytes(CALL_TYPE_CALL, 32), ethers.zeroPadBytes(CALL_TYPE_BATCH, 32)]);
+    });
+
+    it('reverts when any target reverts in default ExecType', async function () {
+      const value1 = 0x012;
+      const value2 = 0x234;
+      const data = encodeBatch(
+        [this.target, value1, this.target.interface.encodeFunctionData('mockFunction')],
+        [this.anotherTarget, value2, this.anotherTarget.interface.encodeFunctionData('mockFunctionRevertsReason')],
+      );
+
+      await expect(this.utils.$execBatch(data, EXEC_TYPE_DEFAULT)).to.be.revertedWith('CallReceiverMock: reverting');
+    });
+
+    it('emits ERC7579TryExecuteFail event when any target reverts in try ExecType', async function () {
+      const value1 = 0x012;
+      const value2 = 0x234;
+      const data = encodeBatch(
+        [this.target, value1, this.target.interface.encodeFunctionData('mockFunction')],
+        [this.anotherTarget, value2, this.anotherTarget.interface.encodeFunctionData('mockFunctionRevertsReason')],
+      );
+
+      await expect(this.utils.$execBatch(data, EXEC_TYPE_TRY))
+        .to.emit(this.utils, 'ERC7579TryExecuteFail')
+        .withArgs(
+          CALL_TYPE_BATCH,
+          ethers.solidityPacked(
+            ['bytes4', 'bytes'],
+            [selector('Error(string)'), coder.encode(['string'], ['CallReceiverMock: reverting'])],
+          ),
+        );
+
+      // Check balances
+      await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1);
+      await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(0);
+    });
+
+    it('reverts with an invalid exec type', async function () {
+      const value1 = 0x012;
+      const value2 = 0x234;
+      const data = encodeBatch(
+        [this.target, value1, this.target.interface.encodeFunctionData('mockFunction')],
+        [this.anotherTarget, value2, this.anotherTarget.interface.encodeFunctionData('mockFunction')],
+      );
+
+      await expect(this.utils.$execBatch(data, '0x03'))
+        .to.be.revertedWithCustomError(this.utils, 'ERC7579UnsupportedExecType')
+        .withArgs('0x03');
+    });
+  });
+
+  describe('execDelegateCall', function () {
+    it('delegate calls the target', async function () {
+      const slot = ethers.hexlify(ethers.randomBytes(32));
+      const value = ethers.hexlify(ethers.randomBytes(32));
+      const data = encodeDelegate(
+        this.target,
+        this.target.interface.encodeFunctionData('mockFunctionWritesStorage', [slot, value]),
+      );
+
+      await expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(ethers.ZeroHash);
+      await this.utils.$execDelegateCall(data, EXEC_TYPE_DEFAULT);
+      await expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(value);
+    });
+
+    it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () {
+      const data = encodeDelegate(
+        ethers.ZeroAddress,
+        this.utils.interface.encodeFunctionData('$CALLTYPE_DELEGATECALL', []),
+      );
+
+      await expect(this.utils.$execDelegateCall(data, EXEC_TYPE_DEFAULT))
+        .to.emit(this.utils, 'return$execDelegateCall')
+        .withArgs([ethers.zeroPadBytes(CALL_TYPE_DELEGATE, 32)]);
+    });
+
+    it('reverts when target reverts in default ExecType', async function () {
+      const data = encodeDelegate(this.target, this.target.interface.encodeFunctionData('mockFunctionRevertsReason'));
+      await expect(this.utils.$execDelegateCall(data, EXEC_TYPE_DEFAULT)).to.be.revertedWith(
+        'CallReceiverMock: reverting',
+      );
+    });
+
+    it('emits ERC7579TryExecuteFail event when target reverts in try ExecType', async function () {
+      const data = encodeDelegate(this.target, this.target.interface.encodeFunctionData('mockFunctionRevertsReason'));
+      await expect(this.utils.$execDelegateCall(data, EXEC_TYPE_TRY))
+        .to.emit(this.utils, 'ERC7579TryExecuteFail')
+        .withArgs(
+          CALL_TYPE_CALL,
+          ethers.solidityPacked(
+            ['bytes4', 'bytes'],
+            [selector('Error(string)'), coder.encode(['string'], ['CallReceiverMock: reverting'])],
+          ),
+        );
+    });
+
+    it('reverts with an invalid exec type', async function () {
+      const data = encodeDelegate(this.target, this.target.interface.encodeFunctionData('mockFunction'));
+      await expect(this.utils.$execDelegateCall(data, '0x03'))
+        .to.be.revertedWithCustomError(this.utils, 'ERC7579UnsupportedExecType')
+        .withArgs('0x03');
+    });
+  });
+
+  it('encodes Mode', async function () {
+    const callType = CALL_TYPE_BATCH;
+    const execType = EXEC_TYPE_TRY;
+    const selector = '0x12345678';
+    const payload = ethers.toBeHex(0, 22);
+
+    await expect(this.utils.$encodeMode(callType, execType, selector, payload)).to.eventually.equal(
+      encodeMode({
+        callType,
+        execType,
+        selector,
+        payload,
+      }),
+    );
+  });
+
+  it('decodes Mode', async function () {
+    const callType = CALL_TYPE_BATCH;
+    const execType = EXEC_TYPE_TRY;
+    const selector = '0x12345678';
+    const payload = ethers.toBeHex(0, 22);
+
+    await expect(
+      this.utils.$decodeMode(
+        encodeMode({
+          callType,
+          execType,
+          selector,
+          payload,
+        }),
+      ),
+    ).to.eventually.deep.equal([callType, execType, selector, payload]);
+  });
+
+  it('encodes single', async function () {
+    const target = this.target;
+    const value = 0x123;
+    const data = '0x12345678';
+
+    await expect(this.utils.$encodeSingle(target, value, data)).to.eventually.equal(encodeSingle(target, value, data));
+  });
+
+  it('decodes single', async function () {
+    const target = this.target;
+    const value = 0x123;
+    const data = '0x12345678';
+
+    await expect(this.utils.$decodeSingle(encodeSingle(target, value, data))).to.eventually.deep.equal([
+      target.target,
+      value,
+      data,
+    ]);
+  });
+
+  it('encodes batch', async function () {
+    const entries = [
+      [this.target, 0x123, '0x12345678'],
+      [this.anotherTarget, 0x456, '0x12345678'],
+    ];
+
+    await expect(this.utils.$encodeBatch(entries)).to.eventually.equal(encodeBatch(...entries));
+  });
+
+  it('decodes batch', async function () {
+    const entries = [
+      [this.target.target, 0x123, '0x12345678'],
+      [this.anotherTarget.target, 0x456, '0x12345678'],
+    ];
+
+    await expect(this.utils.$decodeBatch(encodeBatch(...entries))).to.eventually.deep.equal(entries);
+  });
+
+  it('encodes delegate', async function () {
+    const target = this.target;
+    const data = '0x12345678';
+
+    await expect(this.utils.$encodeDelegate(target, data)).to.eventually.equal(encodeDelegate(target, data));
+  });
+
+  it('decodes delegate', async function () {
+    const target = this.target;
+    const data = '0x12345678';
+
+    await expect(this.utils.$decodeDelegate(encodeDelegate(target, data))).to.eventually.deep.equal([
+      target.target,
+      data,
+    ]);
+  });
+
+  describe('global', function () {
+    describe('eqCallTypeGlobal', function () {
+      it('returns true if both call types are equal', async function () {
+        await expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_BATCH, CALL_TYPE_BATCH)).to.eventually.be.true;
+      });
+
+      it('returns false if both call types are different', async function () {
+        await expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_CALL, CALL_TYPE_BATCH)).to.eventually.be.false;
+      });
+    });
+
+    describe('eqExecTypeGlobal', function () {
+      it('returns true if both exec types are equal', async function () {
+        await expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_TRY, EXEC_TYPE_TRY)).to.eventually.be.true;
+      });
+
+      it('returns false if both exec types are different', async function () {
+        await expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_DEFAULT, EXEC_TYPE_TRY)).to.eventually.be.false;
+      });
+    });
+
+    describe('eqModeSelectorGlobal', function () {
+      it('returns true if both selectors are equal', async function () {
+        await expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x12345678')).to.eventually.be.true;
+      });
+
+      it('returns false if both selectors are different', async function () {
+        await expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x87654321')).to.eventually.be.false;
+      });
+    });
+
+    describe('eqModePayloadGlobal', function () {
+      it('returns true if both payloads are equal', async function () {
+        await expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(0, 22))).to.eventually
+          .be.true;
+      });
+
+      it('returns false if both payloads are different', async function () {
+        await expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(1, 22))).to.eventually
+          .be.false;
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/crosschain/BridgeERC20.behavior.js

@@ -0,0 +1,163 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { anyValue } = require('@nomicfoundation/hardhat-chai-matchers/withArgs');
+
+const amount = 100n;
+
+function shouldBehaveLikeBridgeERC20({ chainAIsCustodial = false, chainBIsCustodial = false } = {}) {
+  beforeEach(function () {
+    // helper
+    this.encodePayload = (from, to, amount) =>
+      ethers.AbiCoder.defaultAbiCoder().encode(
+        ['bytes', 'bytes', 'uint256'],
+        [this.chain.toErc7930(from), to.target ?? to.address ?? to, amount],
+      );
+  });
+
+  it('bridge setup', async function () {
+    await expect(this.bridgeA.getLink(this.chain.erc7930)).to.eventually.deep.equal([
+      this.gateway.target,
+      this.chain.toErc7930(this.bridgeB),
+    ]);
+    await expect(this.bridgeB.getLink(this.chain.erc7930)).to.eventually.deep.equal([
+      this.gateway.target,
+      this.chain.toErc7930(this.bridgeA),
+    ]);
+  });
+
+  it('crosschain send (both direction)', async function () {
+    const [alice, bruce, chris] = this.accounts;
+
+    await this.tokenA.$_mint(alice, amount);
+    await this.tokenA.connect(alice).approve(this.bridgeA, ethers.MaxUint256);
+
+    // Alice sends tokens from chain A to Bruce on chain B.
+    await expect(this.bridgeA.connect(alice).crosschainTransfer(this.chain.toErc7930(bruce), amount))
+      // bridge on chain A takes custody of the funds
+      .to.emit(this.tokenA, 'Transfer')
+      .withArgs(alice, chainAIsCustodial ? this.bridgeA : ethers.ZeroAddress, amount)
+      // crosschain transfer sent
+      .to.emit(this.bridgeA, 'CrosschainERC20TransferSent')
+      .withArgs(anyValue, alice, this.chain.toErc7930(bruce), amount)
+      // ERC-7786 event
+      .to.emit(this.gateway, 'MessageSent')
+      // crosschain transfer received
+      .to.emit(this.bridgeB, 'CrosschainERC20TransferReceived')
+      .withArgs(anyValue, this.chain.toErc7930(alice), bruce, amount)
+      // crosschain mint event
+      .to.emit(this.tokenB, 'CrosschainMint')
+      .withArgs(bruce, amount, this.bridgeB)
+      // tokens are minted on chain B
+      .to.emit(this.tokenB, 'Transfer')
+      .withArgs(chainBIsCustodial ? this.bridgeB : ethers.ZeroAddress, bruce, amount);
+
+    // Bruce sends tokens from chain B to Chris on chain A.
+    await expect(this.bridgeB.connect(bruce).crosschainTransfer(this.chain.toErc7930(chris), amount))
+      // tokens are burned on chain B
+      .to.emit(this.tokenB, 'Transfer')
+      .withArgs(bruce, chainBIsCustodial ? this.bridgeB : ethers.ZeroAddress, amount)
+      // crosschain burn event
+      .to.emit(this.tokenB, 'CrosschainBurn')
+      .withArgs(bruce, amount, this.bridgeB)
+      // crosschain transfer sent
+      .to.emit(this.bridgeB, 'CrosschainERC20TransferSent')
+      .withArgs(anyValue, bruce, this.chain.toErc7930(chris), amount)
+      // ERC-7786 event
+      .to.emit(this.gateway, 'MessageSent')
+      // crosschain transfer received
+      .to.emit(this.bridgeA, 'CrosschainERC20TransferReceived')
+      .withArgs(anyValue, this.chain.toErc7930(bruce), chris, amount)
+      // bridge on chain A releases custody of the funds
+      .to.emit(this.tokenA, 'Transfer')
+      .withArgs(chainAIsCustodial ? this.bridgeA : ethers.ZeroAddress, chris, amount);
+  });
+
+  describe('restrictions', function () {
+    beforeEach(async function () {
+      await this.tokenA.$_mint(this.bridgeA, 1_000_000_000n);
+    });
+
+    it('only gateway can relay messages', async function () {
+      const [notGateway] = this.accounts;
+
+      await expect(
+        this.bridgeA
+          .connect(notGateway)
+          .receiveMessage(
+            ethers.ZeroHash,
+            this.chain.toErc7930(this.tokenB),
+            this.encodePayload(notGateway, notGateway, amount),
+          ),
+      )
+        .to.be.revertedWithCustomError(this.bridgeA, 'ERC7786RecipientUnauthorizedGateway')
+        .withArgs(notGateway, this.chain.toErc7930(this.tokenB));
+    });
+
+    it('only counterpart can send a crosschain message', async function () {
+      const [invalid] = this.accounts;
+
+      await expect(
+        this.gateway
+          .connect(invalid)
+          .sendMessage(this.chain.toErc7930(this.bridgeA), this.encodePayload(invalid, invalid, amount), []),
+      )
+        .to.be.revertedWithCustomError(this.bridgeA, 'ERC7786RecipientUnauthorizedGateway')
+        .withArgs(this.gateway, this.chain.toErc7930(invalid));
+    });
+
+    it('cannot replay message', async function () {
+      const [from, to] = this.accounts;
+
+      const id = ethers.ZeroHash;
+      const payload = this.encodePayload(from, to, amount);
+
+      // first time works
+      await expect(
+        this.bridgeA.connect(this.gatewayAsEOA).receiveMessage(id, this.chain.toErc7930(this.bridgeB), payload),
+      ).to.emit(this.bridgeA, 'CrosschainERC20TransferReceived');
+
+      // second time fails
+      await expect(
+        this.bridgeA.connect(this.gatewayAsEOA).receiveMessage(id, this.chain.toErc7930(this.bridgeB), payload),
+      )
+        .to.be.revertedWithCustomError(this.bridgeA, 'ERC7786RecipientMessageAlreadyProcessed')
+        .withArgs(this.gateway, id);
+    });
+  });
+
+  describe('reconfiguration', function () {
+    it('updating a link emits an event', async function () {
+      const newGateway = await ethers.deployContract('$ERC7786GatewayMock');
+      const newCounterpart = this.chain.toErc7930(this.accounts[0]);
+
+      await expect(this.bridgeA.$_setLink(newGateway, newCounterpart, true))
+        .to.emit(this.bridgeA, 'LinkRegistered')
+        .withArgs(newGateway, newCounterpart);
+
+      await expect(this.bridgeA.getLink(this.chain.erc7930)).to.eventually.deep.equal([
+        newGateway.target,
+        newCounterpart,
+      ]);
+    });
+
+    it('cannot override configuration is "allowOverride" is false', async function () {
+      const newGateway = await ethers.deployContract('$ERC7786GatewayMock');
+      const newCounterpart = this.chain.toErc7930(this.accounts[0]);
+
+      await expect(this.bridgeA.$_setLink(newGateway, newCounterpart, false))
+        .to.be.revertedWithCustomError(this.bridgeA, 'LinkAlreadyRegistered')
+        .withArgs(this.chain.erc7930);
+    });
+
+    it('reject invalid gateway', async function () {
+      const notAGateway = this.accounts[0];
+      const newCounterpart = this.chain.toErc7930(this.accounts[0]);
+
+      await expect(this.bridgeA.$_setLink(notAGateway, newCounterpart, false)).to.be.revertedWithoutReason();
+    });
+  });
+}
+
+module.exports = {
+  shouldBehaveLikeBridgeERC20,
+};

package/lib/openzeppelin-contracts/test/crosschain/BridgeERC20.test.js

@@ -0,0 +1,46 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { impersonate } = require('../helpers/account');
+const { getLocalChain } = require('../helpers/chains');
+
+const { shouldBehaveLikeBridgeERC20 } = require('./BridgeERC20.behavior');
+
+async function fixture() {
+  const chain = await getLocalChain();
+  const accounts = await ethers.getSigners();
+
+  // Mock gateway
+  const gateway = await ethers.deployContract('$ERC7786GatewayMock');
+  const gatewayAsEOA = await impersonate(gateway);
+
+  // Chain A: legacy ERC20 with bridge
+  const tokenA = await ethers.deployContract('$ERC20', ['Token1', 'T1']);
+  const bridgeA = await ethers.deployContract('$BridgeERC20', [[], tokenA]);
+
+  // Chain B: ERC7802 with bridge (preconfigured link to bridgeA)
+  const tokenB = await ethers.deployContract('$ERC20BridgeableMock', ['Token2', 'T2', ethers.ZeroAddress]);
+  const bridgeB = await ethers.deployContract('$BridgeERC7802', [[[gateway, chain.toErc7930(bridgeA)]], tokenB]);
+
+  // deployment check + counterpart setup
+  await expect(bridgeA.$_setLink(gateway, chain.toErc7930(bridgeB), false))
+    .to.emit(bridgeA, 'LinkRegistered')
+    .withArgs(gateway, chain.toErc7930(bridgeB));
+  await tokenB.$_setBridge(bridgeB);
+
+  return { chain, accounts, gateway, gatewayAsEOA, tokenA, tokenB, bridgeA, bridgeB };
+}
+
+describe('CrosschainBridgeERC20', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('token getters', async function () {
+    await expect(this.bridgeA.token()).to.eventually.equal(this.tokenA);
+    await expect(this.bridgeB.token()).to.eventually.equal(this.tokenB);
+  });
+
+  shouldBehaveLikeBridgeERC20({ chainAIsCustodial: true });
+});

package/lib/openzeppelin-contracts/test/crosschain/ERC7786Recipient.test.js

@@ -0,0 +1,73 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { getLocalChain } = require('../helpers/chains');
+const { impersonate } = require('../helpers/account');
+const { generators } = require('../helpers/random');
+
+const value = 42n;
+const payload = generators.hexBytes(128);
+const attributes = [];
+
+async function fixture() {
+  const [sender, notAGateway] = await ethers.getSigners();
+  const { toErc7930 } = await getLocalChain();
+
+  const gateway = await ethers.deployContract('$ERC7786GatewayMock');
+  const receiver = await ethers.deployContract('$ERC7786RecipientMock', [gateway]);
+
+  return { sender, notAGateway, gateway, receiver, toErc7930 };
+}
+
+// NOTE: here we are only testing the receiver. Failures of the gateway itself (invalid attributes, ...) are out of scope.
+describe('ERC7786Recipient', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('receives gateway relayed messages', async function () {
+    await expect(
+      this.gateway.connect(this.sender).sendMessage(this.toErc7930(this.receiver), payload, attributes, { value }),
+    )
+      .to.emit(this.gateway, 'MessageSent')
+      .withArgs(ethers.ZeroHash, this.toErc7930(this.sender), this.toErc7930(this.receiver), payload, value, attributes)
+      .to.emit(this.receiver, 'MessageReceived')
+      .withArgs(this.gateway, ethers.toBeHex(1n, 32n), this.toErc7930(this.sender), payload, value);
+  });
+
+  it('receive multiple similar messages (with different receiveIds)', async function () {
+    for (let i = 1n; i < 5n; ++i) {
+      await expect(
+        this.gateway.connect(this.sender).sendMessage(this.toErc7930(this.receiver), payload, attributes, { value }),
+      )
+        .to.emit(this.receiver, 'MessageReceived')
+        .withArgs(this.gateway, ethers.toBeHex(i, 32n), this.toErc7930(this.sender), payload, value);
+    }
+  });
+
+  it('multiple use of the same receiveId', async function () {
+    const gatewayAsEOA = await impersonate(this.gateway.target);
+    const receiveId = ethers.toBeHex(1n, 32n);
+
+    await expect(
+      this.receiver.connect(gatewayAsEOA).receiveMessage(receiveId, this.toErc7930(this.sender), payload, { value }),
+    )
+      .to.emit(this.receiver, 'MessageReceived')
+      .withArgs(this.gateway, receiveId, this.toErc7930(this.sender), payload, value);
+
+    await expect(
+      this.receiver.connect(gatewayAsEOA).receiveMessage(receiveId, this.toErc7930(this.sender), payload, { value }),
+    )
+      .to.be.revertedWithCustomError(this.receiver, 'ERC7786RecipientMessageAlreadyProcessed')
+      .withArgs(this.gateway, receiveId);
+  });
+
+  it('unauthorized call', async function () {
+    await expect(
+      this.receiver.connect(this.notAGateway).receiveMessage(ethers.ZeroHash, this.toErc7930(this.sender), payload),
+    )
+      .to.be.revertedWithCustomError(this.receiver, 'ERC7786RecipientUnauthorizedGateway')
+      .withArgs(this.notAGateway, this.toErc7930(this.sender));
+  });
+});