openzeppelin-contracts/test/helpers/crosschain.js

const { promisify } = require('util');

const BridgeAMBMock = artifacts.require('BridgeAMBMock');
const BridgeArbitrumL1Mock = artifacts.require('BridgeArbitrumL1Mock');
const BridgeArbitrumL2Mock = artifacts.require('BridgeArbitrumL2Mock');
const BridgeOptimismMock = artifacts.require('BridgeOptimismMock');
const BridgePolygonChildMock = artifacts.require('BridgePolygonChildMock');

class BridgeHelper {
  static async deploy (type) {
    return new BridgeHelper(await deployBridge(type));
  }

  constructor (bridge) {
    this.bridge = bridge;
    this.address = bridge.address;
  }

  call (from, target, selector = undefined, args = []) {
    return this.bridge.relayAs(
      target.address || target,
      selector
        ? target.contract.methods[selector](...args).encodeABI()
        : '0x',
      from,
    );
  }
}

async function deployBridge (type = 'Arbitrum-L2') {
  switch (type) {
  case 'AMB':
    return BridgeAMBMock.new();

  case 'Arbitrum-L1':
    return BridgeArbitrumL1Mock.new();

  case 'Arbitrum-L2': {
    const instance = await BridgeArbitrumL2Mock.new();
    const code = await web3.eth.getCode(instance.address);
    await promisify(web3.currentProvider.send.bind(web3.currentProvider))({
      jsonrpc: '2.0',
      method: 'hardhat_setCode',
      params: [ '0x0000000000000000000000000000000000000064', code ],
      id: new Date().getTime(),
    });
    return BridgeArbitrumL2Mock.at('0x0000000000000000000000000000000000000064');
  }

  case 'Optimism':
    return BridgeOptimismMock.new();

  case 'Polygon-Child':
    return BridgePolygonChildMock.new();

  default:
    throw new Error(`CrossChain: ${type} is not supported`);
  }
}

module.exports = {
  BridgeHelper,
};