web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/helpers/chains.js

@@ -0,0 +1,56 @@
+// The following listing does not pretend to be exhaustive or even accurate. It SHOULD NOT be used in production.
+
+const { ethers } = require('hardhat');
+const { mapValues } = require('./iterate');
+
+const { addressCoder } = require('interoperable-addresses');
+
+// EVM (https://axelarscan.io/resources/chains?type=evm)
+const ethereum = {
+  Ethereum: 1n,
+  optimism: 10n,
+  binance: 56n,
+  Polygon: 137n,
+  Fantom: 250n,
+  fraxtal: 252n,
+  filecoin: 314n,
+  Moonbeam: 1284n,
+  centrifuge: 2031n,
+  kava: 2222n,
+  mantle: 5000n,
+  base: 8453n,
+  immutable: 13371n,
+  arbitrum: 42161n,
+  celo: 42220n,
+  Avalanche: 43114n,
+  linea: 59144n,
+  blast: 81457n,
+  scroll: 534352n,
+  aurora: 1313161554n,
+};
+
+const solana = {
+  Mainnet: '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d',
+};
+
+const format = ({ namespace, reference }) => ({
+  namespace,
+  reference: reference.toString(),
+  caip2: `${namespace}:${reference}`,
+  erc7930: addressCoder.encode({ chainType: namespace, reference }),
+  toCaip10: other => `${namespace}:${reference}:${ethers.getAddress(other.target ?? other.address ?? other)}`,
+  toErc7930: other =>
+    addressCoder.encode({ chainType: namespace, reference, address: other.target ?? other.address ?? other }),
+});
+
+module.exports = {
+  CHAINS: mapValues(
+    Object.assign(
+      mapValues(ethereum, reference => ({ namespace: 'eip155', reference })),
+      mapValues(solana, reference => ({ namespace: 'solana', reference })),
+    ),
+    format,
+  ),
+  getLocalChain: () =>
+    ethers.provider.getNetwork().then(({ chainId }) => format({ namespace: 'eip155', reference: chainId })),
+};

package/lib/openzeppelin-contracts/test/helpers/constants.js

@@ -0,0 +1,7 @@
+module.exports = {
+  MAX_UINT16: 2n ** 16n - 1n,
+  MAX_UINT32: 2n ** 32n - 1n,
+  MAX_UINT48: 2n ** 48n - 1n,
+  MAX_UINT64: 2n ** 64n - 1n,
+  MAX_UINT128: 2n ** 128n - 1n,
+};

package/lib/openzeppelin-contracts/test/helpers/deploy.js

@@ -0,0 +1,14 @@
+const { artifacts, ethers } = require('hardhat');
+const { setCode } = require('@nomicfoundation/hardhat-network-helpers');
+const { generators } = require('./random');
+
+const forceDeployCode = (name, address = generators.address(), runner = ethers.provider) =>
+  artifacts
+    .readArtifact(name)
+    .then(({ abi, deployedBytecode }) =>
+      setCode(address, deployedBytecode).then(() => new ethers.Contract(address, abi, runner)),
+    );
+
+module.exports = {
+  forceDeployCode,
+};

package/lib/openzeppelin-contracts/test/helpers/eip712-types.js

@@ -0,0 +1,61 @@
+const { mapValues } = require('./iterate');
+
+const formatType = schema => Object.entries(schema).map(([name, type]) => ({ name, type }));
+
+module.exports = mapValues(
+  {
+    EIP712Domain: {
+      name: 'string',
+      version: 'string',
+      chainId: 'uint256',
+      verifyingContract: 'address',
+      salt: 'bytes32',
+    },
+    Permit: { owner: 'address', spender: 'address', value: 'uint256', nonce: 'uint256', deadline: 'uint256' },
+    Ballot: { proposalId: 'uint256', support: 'uint8', voter: 'address', nonce: 'uint256' },
+    ExtendedBallot: {
+      proposalId: 'uint256',
+      support: 'uint8',
+      voter: 'address',
+      nonce: 'uint256',
+      reason: 'string',
+      params: 'bytes',
+    },
+    OverrideBallot: { proposalId: 'uint256', support: 'uint8', voter: 'address', nonce: 'uint256', reason: 'string' },
+    Delegation: { delegatee: 'address', nonce: 'uint256', expiry: 'uint256' },
+    ForwardRequest: {
+      from: 'address',
+      to: 'address',
+      value: 'uint256',
+      gas: 'uint256',
+      nonce: 'uint256',
+      deadline: 'uint48',
+      data: 'bytes',
+    },
+    PackedUserOperation: {
+      sender: 'address',
+      nonce: 'uint256',
+      initCode: 'bytes',
+      callData: 'bytes',
+      accountGasLimits: 'bytes32',
+      preVerificationGas: 'uint256',
+      gasFees: 'bytes32',
+      paymasterAndData: 'bytes',
+    },
+    UserOperationRequest: {
+      sender: 'address',
+      nonce: 'uint256',
+      initCode: 'bytes',
+      callData: 'bytes',
+      accountGasLimits: 'bytes32',
+      preVerificationGas: 'uint256',
+      gasFees: 'bytes32',
+      paymasterVerificationGasLimit: 'uint256',
+      paymasterPostOpGasLimit: 'uint256',
+      validAfter: 'uint48',
+      validUntil: 'uint48',
+    },
+  },
+  formatType,
+);
+module.exports.formatType = formatType;

package/lib/openzeppelin-contracts/test/helpers/eip712.js

@@ -0,0 +1,45 @@
+const { ethers } = require('hardhat');
+const types = require('./eip712-types');
+
+async function getDomain(contract) {
+  const { fields, name, version, chainId, verifyingContract, salt, extensions } = await contract.eip712Domain();
+
+  if (extensions.length > 0) {
+    throw Error('Extensions not implemented');
+  }
+
+  const domain = {
+    name,
+    version,
+    chainId,
+    verifyingContract,
+    salt,
+  };
+
+  for (const [i, { name }] of types.EIP712Domain.entries()) {
+    if (!(fields & (1 << i))) {
+      delete domain[name];
+    }
+  }
+
+  return domain;
+}
+
+function domainType(domain) {
+  return types.EIP712Domain.filter(({ name }) => domain[name] !== undefined);
+}
+
+function hashTypedData(domain, structHash) {
+  return ethers.solidityPackedKeccak256(
+    ['bytes', 'bytes32', 'bytes32'],
+    ['0x1901', ethers.TypedDataEncoder.hashDomain(domain), structHash],
+  );
+}
+
+module.exports = {
+  getDomain,
+  domainType,
+  domainSeparator: ethers.TypedDataEncoder.hashDomain,
+  hashTypedData,
+  ...types,
+};

package/lib/openzeppelin-contracts/test/helpers/enums.js

@@ -0,0 +1,15 @@
+const { ethers } = require('ethers');
+
+const Enum = (...options) => Object.fromEntries(options.map((key, i) => [key, BigInt(i)]));
+const EnumTyped = (...options) => Object.fromEntries(options.map((key, i) => [key, ethers.Typed.uint8(i)]));
+
+module.exports = {
+  Enum,
+  EnumTyped,
+  ProposalState: Enum('Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'),
+  VoteType: Object.assign(Enum('Against', 'For', 'Abstain'), { Parameters: 255n }),
+  Rounding: EnumTyped('Floor', 'Ceil', 'Trunc', 'Expand'),
+  OperationState: Enum('Unset', 'Waiting', 'Ready', 'Done'),
+  RevertType: EnumTyped('None', 'RevertWithoutMessage', 'RevertWithMessage', 'RevertWithCustomError', 'Panic'),
+  ValidationRange: Enum('Timestamp', 'Block'),
+};

package/lib/openzeppelin-contracts/test/helpers/erc4337.js

@@ -0,0 +1,244 @@
+const { ethers, config, predeploy } = require('hardhat');
+const { ValidationRange } = require('./enums');
+
+const SIG_VALIDATION_SUCCESS = '0x0000000000000000000000000000000000000000';
+const SIG_VALIDATION_FAILURE = '0x0000000000000000000000000000000000000001';
+const PAYMASTER_SIG_MAGIC = '0x22e325a297439656';
+
+const BLOCK_RANGE_FLAG = 0x800000000000n;
+const BLOCK_RANGE_MASK = 0x7fffffffffffn;
+
+function getAddress(account) {
+  return account.target ?? account.address ?? account;
+}
+
+function pack(left, right) {
+  return ethers.solidityPacked(['uint128', 'uint128'], [left, right]);
+}
+
+function packValidationData(validAfter, validUntil, authorizer, range = undefined) {
+  // if range is not specified, use the value as provided,
+  // otherwise, clean the values (& BLOCK_RANGE_MASK) and set the flag if corresponding to the range.
+  return ethers.solidityPacked(
+    ['uint48', 'uint48', 'address'],
+    [
+      range === undefined
+        ? BigInt(validAfter)
+        : (BigInt(validAfter) & BLOCK_RANGE_MASK) | (range == ValidationRange.Block ? BLOCK_RANGE_FLAG : 0n),
+      range === undefined
+        ? BigInt(validUntil)
+        : (BigInt(validUntil) & BLOCK_RANGE_MASK) | (range == ValidationRange.Block ? BLOCK_RANGE_FLAG : 0n),
+      typeof authorizer == 'boolean'
+        ? authorizer
+          ? SIG_VALIDATION_SUCCESS
+          : SIG_VALIDATION_FAILURE
+        : getAddress(authorizer),
+    ],
+  );
+}
+
+function packInitCode(factory, factoryData) {
+  return ethers.solidityPacked(['address', 'bytes'], [getAddress(factory), factoryData]);
+}
+
+function packPaymasterAndData(
+  paymaster,
+  paymasterVerificationGasLimit,
+  paymasterPostOpGasLimit,
+  paymasterData,
+  signature = undefined,
+) {
+  return ethers.concat([
+    ethers.solidityPacked(
+      ['address', 'uint128', 'uint128', 'bytes'],
+      [getAddress(paymaster), paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymasterData],
+    ),
+    signature === undefined
+      ? '0x'
+      : ethers.solidityPacked(
+          ['bytes', 'uint16', 'bytes8'],
+          [signature, ethers.dataLength(signature), PAYMASTER_SIG_MAGIC],
+        ),
+  ]);
+}
+
+/// Represent one user operation
+class UserOperation {
+  constructor(params) {
+    this.sender = getAddress(params.sender);
+    this.nonce = params.nonce;
+    this.factory = params.factory ?? undefined;
+    this.factoryData = params.factoryData ?? '0x';
+    this.callData = params.callData ?? '0x';
+    this.verificationGas = params.verificationGas ?? 10_000_000n;
+    this.callGas = params.callGas ?? 100_000n;
+    this.preVerificationGas = params.preVerificationGas ?? 100_000n;
+    this.maxPriorityFee = params.maxPriorityFee ?? 100_000n;
+    this.maxFeePerGas = params.maxFeePerGas ?? 100_000n;
+    this.paymaster = params.paymaster ?? undefined;
+    this.paymasterVerificationGasLimit = params.paymasterVerificationGasLimit ?? 0n;
+    this.paymasterPostOpGasLimit = params.paymasterPostOpGasLimit ?? 0n;
+    this.paymasterData = params.paymasterData ?? '0x';
+    this.paymasterSignature = params.paymasterSignature ?? undefined;
+    this.signature = params.signature ?? '0x';
+  }
+
+  get packed() {
+    return {
+      sender: this.sender,
+      nonce: this.nonce,
+      initCode: this.factory ? packInitCode(this.factory, this.factoryData) : '0x',
+      callData: this.callData,
+      accountGasLimits: pack(this.verificationGas, this.callGas),
+      preVerificationGas: this.preVerificationGas,
+      gasFees: pack(this.maxPriorityFee, this.maxFeePerGas),
+      paymasterAndData: this.paymaster
+        ? packPaymasterAndData(
+            this.paymaster,
+            this.paymasterVerificationGasLimit,
+            this.paymasterPostOpGasLimit,
+            this.paymasterData,
+            this.paymasterSignature,
+          )
+        : '0x',
+      signature: this.signature,
+    };
+  }
+
+  hash(entrypoint) {
+    return entrypoint.getUserOpHash(this.packed);
+  }
+}
+
+const parseInitCode = initCode => ({
+  factory: '0x' + initCode.replace(/0x/, '').slice(0, 40),
+  factoryData: '0x' + initCode.replace(/0x/, '').slice(40),
+});
+
+/// Global ERC-4337 environment helper.
+class ERC4337Helper {
+  constructor() {
+    this.factoryAsPromise = ethers.deployContract('$Create2');
+  }
+
+  async wait() {
+    this.factory = await this.factoryAsPromise;
+    return this;
+  }
+
+  async newAccount(name, extraArgs = [], params = {}) {
+    const env = {
+      entrypoint: params.entrypoint ?? predeploy.entrypoint.v09,
+      senderCreator: params.senderCreator ?? predeploy.senderCreator.v09,
+    };
+
+    const { factory } = await this.wait();
+
+    const accountFactory = await ethers.getContractFactory(name);
+
+    if (params.eip7702signer) {
+      const delegate = await accountFactory.deploy(...extraArgs);
+      const instance = await params.eip7702signer.getAddress().then(address => accountFactory.attach(address));
+      const authorization = await params.eip7702signer.authorize({ address: delegate.target });
+      return new EIP7702SmartAccount(instance, authorization, env);
+    } else {
+      const initCode = await accountFactory
+        .getDeployTransaction(...extraArgs)
+        .then(tx =>
+          factory.interface.encodeFunctionData('$deploy', [0, params.salt ?? ethers.randomBytes(32), tx.data]),
+        )
+        .then(deployCode => ethers.concat([factory.target, deployCode]));
+
+      const instance = await ethers.provider
+        .call({
+          from: env.entrypoint,
+          to: env.senderCreator,
+          data: env.senderCreator.interface.encodeFunctionData('createSender', [initCode]),
+        })
+        .then(result => ethers.getAddress(ethers.hexlify(ethers.getBytes(result).slice(-20))))
+        .then(address => accountFactory.attach(address));
+
+      return new SmartAccount(instance, initCode, env);
+    }
+  }
+}
+
+/// Represent one ERC-4337 account contract.
+class SmartAccount extends ethers.BaseContract {
+  constructor(instance, initCode, env) {
+    super(instance.target, instance.interface, instance.runner, instance.deployTx);
+    this.address = instance.target;
+    this.initCode = initCode;
+    this._env = env;
+  }
+
+  async deploy(account = this.runner) {
+    const { factory: to, factoryData: data } = parseInitCode(this.initCode);
+    this.deployTx = await account.sendTransaction({ to, data });
+    return this;
+  }
+
+  async createUserOp(userOp = {}) {
+    userOp.sender ??= this;
+    userOp.nonce ??= await this._env.entrypoint.getNonce(userOp.sender, 0);
+    if (ethers.isAddressable(userOp.paymaster)) {
+      userOp.paymaster = await ethers.resolveAddress(userOp.paymaster);
+      userOp.paymasterVerificationGasLimit ??= 100_000n;
+      userOp.paymasterPostOpGasLimit ??= 100_000n;
+    }
+    return new UserOperationWithContext(userOp, this._env);
+  }
+}
+
+class EIP7702SmartAccount extends SmartAccount {
+  constructor(instance, authorization, env) {
+    super(instance, undefined, env);
+    this.authorization = authorization;
+  }
+
+  async deploy() {
+    // hardhat signers from @nomicfoundation/hardhat-ethers do not support type 4 txs.
+    // so we rebuild it using "native" ethers
+    await ethers.Wallet.fromPhrase(config.networks.hardhat.accounts.mnemonic, ethers.provider).sendTransaction({
+      to: ethers.ZeroAddress,
+      authorizationList: [this.authorization],
+      gasLimit: 46_000n, // 21,000 base + PER_EMPTY_ACCOUNT_COST
+    });
+
+    return this;
+  }
+}
+
+class UserOperationWithContext extends UserOperation {
+  constructor(userOp, env) {
+    super(userOp);
+    this._sender = userOp.sender;
+    this._env = env;
+  }
+
+  addInitCode() {
+    if (this._sender?.initCode) {
+      return Object.assign(this, parseInitCode(this._sender.initCode));
+    } else throw new Error('No init code available for the sender of this user operation');
+  }
+
+  getAuthorization() {
+    if (this._sender?.authorization) {
+      return this._sender.authorization;
+    } else throw new Error('No EIP-7702 authorization available for the sender of this user operation');
+  }
+
+  hash() {
+    return super.hash(this._env.entrypoint);
+  }
+}
+
+module.exports = {
+  SIG_VALIDATION_SUCCESS,
+  SIG_VALIDATION_FAILURE,
+  packValidationData,
+  packInitCode,
+  packPaymasterAndData,
+  UserOperation,
+  ERC4337Helper,
+};

package/lib/openzeppelin-contracts/test/helpers/erc7579.js

@@ -0,0 +1,58 @@
+const { ethers } = require('hardhat');
+
+const MODULE_TYPE_VALIDATOR = 1;
+const MODULE_TYPE_EXECUTOR = 2;
+const MODULE_TYPE_FALLBACK = 3;
+const MODULE_TYPE_HOOK = 4;
+
+const EXEC_TYPE_DEFAULT = '0x00';
+const EXEC_TYPE_TRY = '0x01';
+
+const CALL_TYPE_CALL = '0x00';
+const CALL_TYPE_BATCH = '0x01';
+const CALL_TYPE_DELEGATE = '0xff';
+
+const encodeMode = ({
+  callType = '0x00',
+  execType = '0x00',
+  selector = '0x00000000',
+  payload = '0x00000000000000000000000000000000000000000000',
+} = {}) =>
+  ethers.solidityPacked(
+    ['bytes1', 'bytes1', 'bytes4', 'bytes4', 'bytes22'],
+    [callType, execType, '0x00000000', selector, payload],
+  );
+
+const encodeSingle = (target, value = 0n, data = '0x') =>
+  ethers.solidityPacked(['address', 'uint256', 'bytes'], [target.target ?? target.address ?? target, value, data]);
+
+const encodeBatch = (...entries) =>
+  ethers.AbiCoder.defaultAbiCoder().encode(
+    ['(address,uint256,bytes)[]'],
+    [
+      entries.map(entry =>
+        Array.isArray(entry)
+          ? [entry[0].target ?? entry[0].address ?? entry[0], entry[1] ?? 0n, entry[2] ?? '0x']
+          : [entry.target.target ?? entry.target.address ?? entry.target, entry.value ?? 0n, entry.data ?? '0x'],
+      ),
+    ],
+  );
+
+const encodeDelegate = (target, data = '0x') =>
+  ethers.solidityPacked(['address', 'bytes'], [target.target ?? target.address ?? target, data]);
+
+module.exports = {
+  MODULE_TYPE_VALIDATOR,
+  MODULE_TYPE_EXECUTOR,
+  MODULE_TYPE_FALLBACK,
+  MODULE_TYPE_HOOK,
+  EXEC_TYPE_DEFAULT,
+  EXEC_TYPE_TRY,
+  CALL_TYPE_CALL,
+  CALL_TYPE_BATCH,
+  CALL_TYPE_DELEGATE,
+  encodeMode,
+  encodeSingle,
+  encodeBatch,
+  encodeDelegate,
+};

package/lib/openzeppelin-contracts/test/helpers/erc7739.js

@@ -0,0 +1,118 @@
+const { ethers } = require('hardhat');
+const { formatType } = require('./eip712');
+
+const PersonalSign = formatType({ prefixed: 'bytes' });
+const TypedDataSign = contentsTypeName =>
+  formatType({
+    contents: contentsTypeName,
+    name: 'string',
+    version: 'string',
+    chainId: 'uint256',
+    verifyingContract: 'address',
+    salt: 'bytes32',
+  });
+
+class ERC7739Signer extends ethers.AbstractSigner {
+  #signer;
+  #domain;
+
+  constructor(signer, domain) {
+    super(signer.provider);
+    this.#signer = signer;
+    this.#domain = domain;
+  }
+
+  static from(signer, domain) {
+    return new this(signer, domain);
+  }
+
+  get signingKey() {
+    return this.#signer.signingKey;
+  }
+
+  get privateKey() {
+    return this.#signer.privateKey;
+  }
+
+  async getAddress() {
+    return this.#signer.getAddress();
+  }
+
+  connect(provider) {
+    this.#signer.connect(provider);
+  }
+
+  async signTransaction(tx) {
+    return this.#signer.signTransaction(tx);
+  }
+
+  async signMessage(message) {
+    return this.#signer.signTypedData(this.#domain, { PersonalSign }, ERC4337Utils.preparePersonalSign(message));
+  }
+
+  async signTypedData(domain, types, value) {
+    const { allTypes, contentsTypeName, contentsDescr } = ERC4337Utils.getContentsDetail(types);
+
+    return Promise.resolve(
+      this.#signer.signTypedData(domain, allTypes, ERC4337Utils.prepareSignTypedData(value, this.#domain)),
+    ).then(signature =>
+      ethers.concat([
+        signature,
+        ethers.TypedDataEncoder.hashDomain(domain), // appDomainSeparator
+        ethers.TypedDataEncoder.hashStruct(contentsTypeName, types, value), // contentsHash
+        ethers.toUtf8Bytes(contentsDescr),
+        ethers.toBeHex(contentsDescr.length, 2),
+      ]),
+    );
+  }
+}
+
+class ERC4337Utils {
+  static preparePersonalSign(message) {
+    return {
+      prefixed: ethers.concat([
+        ethers.toUtf8Bytes(ethers.MessagePrefix),
+        ethers.toUtf8Bytes(String(message.length)),
+        typeof message === 'string' ? ethers.toUtf8Bytes(message) : message,
+      ]),
+    };
+  }
+
+  static prepareSignTypedData(contents, signerDomain) {
+    return {
+      name: signerDomain.name ?? '',
+      version: signerDomain.version ?? '',
+      chainId: signerDomain.chainId ?? 0,
+      verifyingContract: signerDomain.verifyingContract ?? ethers.ZeroAddress,
+      salt: signerDomain.salt ?? ethers.ZeroHash,
+      contents,
+    };
+  }
+
+  static getContentsDetail(contentsTypes, contentsTypeName = Object.keys(contentsTypes).at(0)) {
+    // Examples values
+    //
+    // contentsTypeName         B
+    // typedDataSignType        TypedDataSign(B contents,...)A(uint256 v)B(Z z)Z(A a)
+    // contentsType             A(uint256 v)B(Z z)Z(A a)
+    // contentsDescr            A(uint256 v)B(Z z)Z(A a)B
+    const allTypes = { TypedDataSign: TypedDataSign(contentsTypeName), ...contentsTypes };
+    const typedDataSignType = ethers.TypedDataEncoder.from(allTypes).encodeType('TypedDataSign');
+    const contentsType = typedDataSignType.slice(typedDataSignType.indexOf(')') + 1); // Remove TypedDataSign (first object)
+    const contentsDescr = contentsType + (contentsType.startsWith(contentsTypeName) ? '' : contentsTypeName);
+
+    return {
+      allTypes,
+      contentsTypes,
+      contentsTypeName,
+      contentsDescr,
+    };
+  }
+}
+
+module.exports = {
+  ERC7739Signer,
+  ERC4337Utils,
+  PersonalSign,
+  TypedDataSign,
+};