web3gbit-cli 1.0.0

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

@@ -0,0 +1,218 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { ProposalState } = require('./enums');
+const { unique } = require('./iterate');
+const time = require('./time');
+
+const timelockSalt = (address, descriptionHash) =>
+  ethers.toBeHex((ethers.toBigInt(address) << 96n) ^ ethers.toBigInt(descriptionHash), 32);
+
+class GovernorHelper {
+  constructor(governor, mode = 'blocknumber') {
+    this.governor = governor;
+    this.mode = mode;
+  }
+
+  connect(account) {
+    this.governor = this.governor.connect(account);
+    return this;
+  }
+
+  /// Setter and getters
+  /**
+   * Specify a proposal either as
+   * 1) an array of objects [{ target, value, data }]
+   * 2) an object of arrays { targets: [], values: [], data: [] }
+   */
+  setProposal(actions, description) {
+    if (Array.isArray(actions)) {
+      this.targets = actions.map(a => a.target);
+      this.values = actions.map(a => a.value || 0n);
+      this.data = actions.map(a => a.data || '0x');
+    } else {
+      ({ targets: this.targets, values: this.values, data: this.data } = actions);
+    }
+    this.description = description;
+    return this;
+  }
+
+  get hash() {
+    return ethers.keccak256(
+      ethers.AbiCoder.defaultAbiCoder().encode(['address[]', 'uint256[]', 'bytes[]', 'bytes32'], this.shortProposal),
+    );
+  }
+
+  get id() {
+    return this.governor.latestProposalId ? this.governor.getProposalId(...this.shortProposal) : this.hash;
+  }
+
+  // used for checking events
+  get signatures() {
+    return this.data.map(() => '');
+  }
+
+  get descriptionHash() {
+    return ethers.id(this.description);
+  }
+
+  // condensed version for queueing end executing
+  get shortProposal() {
+    return [this.targets, this.values, this.data, this.descriptionHash];
+  }
+
+  // full version for proposing
+  get fullProposal() {
+    return [this.targets, this.values, this.data, this.description];
+  }
+
+  get currentProposal() {
+    return this;
+  }
+
+  /// Proposal lifecycle
+  delegate(delegation) {
+    return Promise.all([
+      delegation.token.connect(delegation.to).delegate(delegation.to),
+      delegation.value === undefined ||
+        delegation.token.connect(this.governor.runner).transfer(delegation.to, delegation.value),
+      delegation.tokenId === undefined ||
+        delegation.token
+          .ownerOf(delegation.tokenId)
+          .then(owner =>
+            delegation.token.connect(this.governor.runner).transferFrom(owner, delegation.to, delegation.tokenId),
+          ),
+    ]);
+  }
+
+  propose() {
+    return this.governor.propose(...this.fullProposal);
+  }
+
+  queue() {
+    return this.governor.queue(...this.shortProposal);
+  }
+
+  execute() {
+    return this.governor.execute(...this.shortProposal);
+  }
+
+  cancel(visibility = 'external') {
+    switch (visibility) {
+      case 'external':
+        return this.governor.cancel(...this.shortProposal);
+
+      case 'internal':
+        return this.governor.$_cancel(...this.shortProposal);
+
+      default:
+        throw new Error(`unsupported visibility "${visibility}"`);
+    }
+  }
+
+  async vote(vote = {}) {
+    let method = 'castVote'; // default
+    let args = [await this.id, vote.support]; // base
+
+    if (vote.signature) {
+      const sign = await this.forgeMessage(vote).then(msg => vote.signature(this.governor, msg));
+      if (vote.params || vote.reason) {
+        method = 'castVoteWithReasonAndParamsBySig';
+        args.push(vote.voter, vote.reason ?? '', vote.params ?? '0x', sign);
+      } else {
+        method = 'castVoteBySig';
+        args.push(vote.voter, sign);
+      }
+    } else if (vote.params) {
+      method = 'castVoteWithReasonAndParams';
+      args.push(vote.reason ?? '', vote.params);
+    } else if (vote.reason) {
+      method = 'castVoteWithReason';
+      args.push(vote.reason);
+    }
+
+    return await this.governor[method](...args);
+  }
+
+  async overrideVote(vote = {}) {
+    let method = 'castOverrideVote';
+    let args = [await this.id, vote.support];
+
+    vote.reason = vote.reason ?? '';
+
+    if (vote.signature) {
+      const sign = await this.forgeMessage(vote).then(msg => vote.signature(this.governor, { reason: '', ...msg }));
+      method = 'castOverrideVoteBySig';
+      args.push(vote.voter, vote.reason ?? '', sign);
+    }
+
+    return await this.governor[method](...args);
+  }
+
+  /// Clock helpers
+  async waitForSnapshot(offset = 0n) {
+    const timepoint = await this.governor.proposalSnapshot(await this.id);
+    return time.increaseTo[this.mode](timepoint + offset);
+  }
+
+  async waitForDeadline(offset = 0n) {
+    const timepoint = await this.governor.proposalDeadline(await this.id);
+    return time.increaseTo[this.mode](timepoint + offset);
+  }
+
+  async waitForEta(offset = 0n) {
+    const timestamp = await this.governor.proposalEta(await this.id);
+    return time.increaseTo.timestamp(timestamp + offset);
+  }
+
+  /// Other helpers
+  async forgeMessage(vote = {}) {
+    const message = { proposalId: await this.id, support: vote.support, voter: vote.voter, nonce: vote.nonce };
+
+    if (vote.params || vote.reason) {
+      message.reason = vote.reason ?? '';
+      message.params = vote.params ?? '0x';
+    }
+
+    return message;
+  }
+
+  /**
+   * Encodes a list ProposalStates into a bytes32 representation where each bit enabled corresponds to
+   * the underlying position in the `ProposalState` enum. For example:
+   *
+   * 0x000...10000
+   *   ^^^^^^------ ...
+   *         ^----- Succeeded
+   *          ^---- Defeated
+   *           ^--- Canceled
+   *            ^-- Active
+   *             ^- Pending
+   */
+  static proposalStatesToBitMap(proposalStates, options = {}) {
+    if (!Array.isArray(proposalStates)) {
+      proposalStates = [proposalStates];
+    }
+    const statesCount = ethers.toBigInt(Object.keys(ProposalState).length);
+    let result = 0n;
+
+    for (const state of unique(proposalStates)) {
+      if (state < 0n || state >= statesCount) {
+        expect.fail(`ProposalState ${state} out of possible states (0...${statesCount}-1)`);
+      } else {
+        result |= 1n << state;
+      }
+    }
+
+    if (options.inverted) {
+      const mask = 2n ** statesCount - 1n;
+      result = result ^ mask;
+    }
+
+    return ethers.toBeHex(result, 32);
+  }
+}
+
+module.exports = {
+  GovernorHelper,
+  timelockSalt,
+};

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

@@ -0,0 +1,41 @@
+module.exports = {
+  // ================================================= Array helpers =================================================
+
+  // Cut an array into an array of sized-length arrays
+  // Example: chunk([1,2,3,4,5,6,7,8], 3) → [[1,2,3],[4,5,6],[7,8]]
+  chunk: (array, size = 1) =>
+    Array.from({ length: Math.ceil(array.length / size) }, (_, i) => array.slice(i * size, i * size + size)),
+
+  // Cartesian cross product of an array of arrays
+  // Example: product([1,2],[a,b,c],[true]) → [[1,a,true],[1,b,true],[1,c,true],[2,a,true],[2,b,true],[2,c,true]]
+  product: (...arrays) => arrays.reduce((a, b) => a.flatMap(ai => b.map(bi => [...ai, bi])), [[]]),
+
+  // Range from start to end in increment
+  // Example: range(17,42,7) → [17,24,31,38]
+  range: (start, stop = undefined, step = 1) => {
+    if (stop == undefined) {
+      stop = start;
+      start = 0;
+    }
+    return start < stop ? Array.from({ length: (stop - start + step - 1) / step }, (_, i) => start + i * step) : [];
+  },
+
+  // Unique elements, with an optional getter function
+  // Example: unique([1,1,2,3,4,8,1,3,8,13,42]) → [1,2,3,4,8,13,42]
+  unique: (array, op = x => x) => array.filter((obj, i) => array.findIndex(entry => op(obj) === op(entry)) === i),
+
+  // Zip arrays together. If some arrays are smaller, undefined is used as a filler.
+  // Example: zip([1,2],[a,b,c],[true]) → [[1,a,true],[2,b,undefined],[undefined,c,undefined]]
+  zip: (...args) => Array.from({ length: Math.max(...args.map(arg => arg.length)) }, (_, i) => args.map(arg => arg[i])),
+
+  // ================================================ Object helpers =================================================
+
+  // Create a new object by mapping the values through a function, keeping the keys. Second function can be used to pre-filter entries
+  // Example: mapValues({a:1,b:2,c:3}, x => x**2) → {a:1,b:4,c:9}
+  mapValues: (obj, fn, fn2 = () => true) =>
+    Object.fromEntries(
+      Object.entries(obj)
+        .filter(fn2)
+        .map(([k, v]) => [k, fn(v)]),
+    ),
+};

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

@@ -0,0 +1,33 @@
+// Array of number or bigint
+const max = (...values) => values.slice(1).reduce((x, y) => (x > y ? x : y), values.at(0));
+const min = (...values) => values.slice(1).reduce((x, y) => (x < y ? x : y), values.at(0));
+const sum = (...values) => values.slice(1).reduce((x, y) => x + y, values.at(0));
+
+// Computes modexp without BigInt overflow for large numbers
+function modExp(b, e, m) {
+  let result = 1n;
+
+  // If e is a power of two, modexp can be calculated as:
+  // for (let result = b, i = 0; i < log2(e); i++) result = modexp(result, 2, m)
+  //
+  // Given any natural number can be written in terms of powers of 2 (i.e. binary)
+  // then modexp can be calculated for any e, by multiplying b**i for all i where
+  // binary(e)[i] is 1 (i.e. a power of two).
+  for (let base = b % m; e > 0n; base = base ** 2n % m) {
+    // Least significant bit is 1
+    if (e % 2n == 1n) {
+      result = (result * base) % m;
+    }
+
+    e /= 2n; // Binary pop
+  }
+
+  return result;
+}
+
+module.exports = {
+  min,
+  max,
+  sum,
+  modExp,
+};

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

@@ -0,0 +1,14 @@
+const { ethers } = require('hardhat');
+
+const selector = signature => ethers.FunctionFragment.from(signature).selector;
+
+const interfaceId = signatures =>
+  ethers.toBeHex(
+    signatures.reduce((acc, signature) => acc ^ ethers.toBigInt(selector(signature)), 0n),
+    4,
+  );
+
+module.exports = {
+  selector,
+  interfaceId,
+};

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

@@ -0,0 +1,12 @@
+module.exports = {
+  ecRecover: '0x0000000000000000000000000000000000000001',
+  SHA2_256: '0x0000000000000000000000000000000000000002',
+  RIPEMD_160: '0x0000000000000000000000000000000000000003',
+  identity: '0x0000000000000000000000000000000000000004',
+  modexp: '0x0000000000000000000000000000000000000005',
+  ecAdd: '0x0000000000000000000000000000000000000006',
+  ecMul: '0x0000000000000000000000000000000000000007',
+  ecPairing: '0x0000000000000000000000000000000000000008',
+  blake2f: '0x0000000000000000000000000000000000000009',
+  pointEvaluation: '0x000000000000000000000000000000000000000a',
+};

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

@@ -0,0 +1,26 @@
+const { ethers } = require('hardhat');
+
+const generators = {
+  address: () => ethers.Wallet.createRandom().address,
+  bytes32: () => ethers.hexlify(ethers.randomBytes(32)),
+  bytes4: () => ethers.hexlify(ethers.randomBytes(4)),
+  uint256: () => ethers.toBigInt(ethers.randomBytes(32)),
+  int256: () => ethers.toBigInt(ethers.randomBytes(32)) + ethers.MinInt256,
+  bytes: (length = 32) => ethers.hexlify(ethers.randomBytes(length)),
+  string: () => ethers.uuidV4(ethers.randomBytes(32)),
+};
+
+generators.address.zero = ethers.ZeroAddress;
+generators.bytes32.zero = ethers.ZeroHash;
+generators.bytes4.zero = ethers.zeroPadBytes('0x', 4);
+generators.uint256.zero = 0n;
+generators.int256.zero = 0n;
+generators.bytes.zero = '0x';
+generators.string.zero = '';
+
+// alias hexBytes -> bytes
+generators.hexBytes = generators.bytes;
+
+module.exports = {
+  generators,
+};

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

@@ -0,0 +1,222 @@
+const { ethers } = require('ethers');
+const { secp256r1 } = require('@noble/curves/p256');
+const { generateKeyPairSync, privateEncrypt } = require('crypto');
+
+// Lightweight version of BaseWallet
+class NonNativeSigner extends ethers.AbstractSigner {
+  #signingKey;
+
+  constructor(privateKey, provider) {
+    super(provider);
+    ethers.assertArgument(
+      privateKey && typeof privateKey.sign === 'function',
+      'invalid private key',
+      'privateKey',
+      '[ REDACTED ]',
+    );
+    this.#signingKey = privateKey;
+  }
+
+  get signingKey() {
+    return this.#signingKey;
+  }
+  get privateKey() {
+    return this.signingKey.privateKey;
+  }
+
+  async getAddress() {
+    throw new Error("NonNativeSigner doesn't have an address");
+  }
+
+  connect(provider) {
+    return new NonNativeSigner(this.#signingKey, provider);
+  }
+
+  async signTransaction(/*tx: TransactionRequest*/) {
+    throw new Error('NonNativeSigner cannot send transactions');
+  }
+
+  async signMessage(message /*: string | Uint8Array*/) /*: Promise<string>*/ {
+    return this.signingKey.sign(ethers.hashMessage(message)).serialized;
+  }
+
+  async signTypedData(
+    domain /*: TypedDataDomain*/,
+    types /*: Record<string, Array<TypedDataField>>*/,
+    value /*: Record<string, any>*/,
+  ) /*: Promise<string>*/ {
+    // Populate any ENS names
+    const populated = await ethers.TypedDataEncoder.resolveNames(domain, types, value, async name => {
+      ethers.assert(this.provider != null, 'cannot resolve ENS names without a provider', 'UNSUPPORTED_OPERATION', {
+        operation: 'resolveName',
+        info: { name },
+      });
+      const address = await this.provider.resolveName(name);
+      ethers.assert(address != null, 'unconfigured ENS name', 'UNCONFIGURED_NAME', { value: name });
+      return address;
+    });
+
+    return this.signingKey.sign(ethers.TypedDataEncoder.hash(populated.domain, types, populated.value)).serialized;
+  }
+}
+
+class P256SigningKey {
+  #privateKey;
+
+  constructor(privateKey) {
+    this.#privateKey = ethers.getBytes(privateKey);
+  }
+
+  static random() {
+    return new this(secp256r1.utils.randomPrivateKey());
+  }
+
+  get privateKey() {
+    return ethers.hexlify(this.#privateKey);
+  }
+
+  get publicKey() {
+    const publicKeyBytes = secp256r1.getPublicKey(this.#privateKey, false);
+    return {
+      qx: ethers.hexlify(publicKeyBytes.slice(0x01, 0x21)),
+      qy: ethers.hexlify(publicKeyBytes.slice(0x21, 0x41)),
+    };
+  }
+
+  sign(digest /*: BytesLike*/) /*: ethers.Signature*/ {
+    ethers.assertArgument(ethers.dataLength(digest) === 32, 'invalid digest length', 'digest', digest);
+
+    const sig = secp256r1.sign(ethers.getBytesCopy(digest), ethers.getBytesCopy(this.#privateKey), { lowS: true });
+
+    return ethers.Signature.from({
+      r: ethers.toBeHex(sig.r, 32),
+      s: ethers.toBeHex(sig.s, 32),
+      v: sig.recovery ? 0x1c : 0x1b,
+    });
+  }
+}
+
+class RSASigningKey {
+  #privateKey;
+  #publicKey;
+
+  constructor(keyPair) {
+    const jwk = keyPair.publicKey.export({ format: 'jwk' });
+    this.#privateKey = keyPair.privateKey;
+    this.#publicKey = { e: ethers.decodeBase64(jwk.e), n: ethers.decodeBase64(jwk.n) };
+  }
+
+  static random(modulusLength = 2048) {
+    return new this(generateKeyPairSync('rsa', { modulusLength }));
+  }
+
+  get privateKey() {
+    return ethers.hexlify(this.#privateKey);
+  }
+
+  get publicKey() {
+    return { e: ethers.hexlify(this.#publicKey.e), n: ethers.hexlify(this.#publicKey.n) };
+  }
+
+  sign(digest /*: BytesLike*/) /*: ethers.Signature*/ {
+    ethers.assertArgument(ethers.dataLength(digest) === 32, 'invalid digest length', 'digest', digest);
+    // SHA256 OID = 608648016503040201 (9 bytes) | NULL = 0500 (2 bytes) (explicit) | OCTET_STRING length (0x20) = 0420 (2 bytes)
+    return {
+      serialized: ethers.hexlify(
+        privateEncrypt(
+          this.#privateKey,
+          ethers.getBytes(ethers.concat(['0x3031300d060960864801650304020105000420', digest])),
+        ),
+      ),
+    };
+  }
+}
+
+class RSASHA256SigningKey extends RSASigningKey {
+  sign(digest /*: BytesLike*/) /*: ethers.Signature*/ {
+    ethers.assertArgument(ethers.dataLength(digest) === 32, 'invalid digest length', 'digest', digest);
+    return super.sign(ethers.sha256(ethers.getBytes(digest)));
+  }
+}
+
+class WebAuthnSigningKey extends P256SigningKey {
+  sign(digest /*: BytesLike*/) /*: { serialized: string } */ {
+    ethers.assertArgument(ethers.dataLength(digest) === 32, 'invalid digest length', 'digest', digest);
+
+    const clientDataJSON = JSON.stringify({
+      type: 'webauthn.get',
+      challenge: ethers.encodeBase64(digest).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', ''),
+    });
+
+    // Flags 0x05 = AUTH_DATA_FLAGS_UP | AUTH_DATA_FLAGS_UV
+    const authenticatorData = ethers.solidityPacked(
+      ['bytes32', 'bytes1', 'bytes4'],
+      [ethers.ZeroHash, '0x05', '0x00000000'],
+    );
+
+    // Regular P256 signature
+    const { r, s } = super.sign(
+      ethers.sha256(ethers.concat([authenticatorData, ethers.sha256(ethers.toUtf8Bytes(clientDataJSON))])),
+    );
+
+    const serialized = ethers.AbiCoder.defaultAbiCoder().encode(
+      ['bytes32', 'bytes32', 'uint256', 'uint256', 'bytes', 'string'],
+      [
+        r,
+        s,
+        clientDataJSON.indexOf('"challenge"'),
+        clientDataJSON.indexOf('"type"'),
+        authenticatorData,
+        clientDataJSON,
+      ],
+    );
+
+    return { serialized };
+  }
+}
+
+class MultiERC7913SigningKey {
+  // this is a sorted array of objects that contain {signer, weight}
+  #signers;
+
+  constructor(signers) {
+    ethers.assertArgument(
+      Array.isArray(signers) && signers.length > 0,
+      'signers must be a non-empty array',
+      'signers',
+      signers.length,
+    );
+
+    // Sorting is done at construction so that it doesn't have to be done in sign()
+    this.#signers = signers.sort(
+      (s1, s2) => ethers.keccak256(s1.bytes ?? s1.address) - ethers.keccak256(s2.bytes ?? s2.address),
+    );
+  }
+
+  get signers() {
+    return this.#signers;
+  }
+
+  sign(digest /*: BytesLike*/ /*: ethers.Signature*/) {
+    ethers.assertArgument(ethers.dataLength(digest) === 32, 'invalid digest length', 'digest', digest);
+
+    return {
+      serialized: ethers.AbiCoder.defaultAbiCoder().encode(
+        ['bytes[]', 'bytes[]'],
+        [
+          this.#signers.map(signer => signer.bytes ?? signer.address),
+          this.#signers.map(signer => signer.signingKey.sign(digest).serialized),
+        ],
+      ),
+    };
+  }
+}
+
+module.exports = {
+  NonNativeSigner,
+  P256SigningKey,
+  RSASigningKey,
+  RSASHA256SigningKey,
+  WebAuthnSigningKey,
+  MultiERC7913SigningKey,
+};

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

@@ -0,0 +1,48 @@
+const { ethers } = require('hardhat');
+const { setStorageAt } = require('@nomicfoundation/hardhat-network-helpers');
+
+const ImplementationLabel = 'eip1967.proxy.implementation';
+const AdminLabel = 'eip1967.proxy.admin';
+const BeaconLabel = 'eip1967.proxy.beacon';
+
+const erc1967Slot = label => ethers.toBeHex(ethers.toBigInt(ethers.id(label)) - 1n);
+const erc7201Slot = label => ethers.toBeHex(ethers.toBigInt(ethers.keccak256(erc1967Slot(label))) & ~0xffn);
+const erc7201format = contractName => `openzeppelin.storage.${contractName}`;
+
+const getSlot = (address, slot) =>
+  ethers.provider.getStorage(address, ethers.isBytesLike(slot) ? slot : erc1967Slot(slot));
+
+const setSlot = (address, slot, value) =>
+  Promise.all([
+    ethers.isAddressable(address) ? address.getAddress() : Promise.resolve(address),
+    ethers.isAddressable(value) ? value.getAddress() : Promise.resolve(value),
+  ]).then(([address, value]) => setStorageAt(address, ethers.isBytesLike(slot) ? slot : erc1967Slot(slot), value));
+
+const getAddressInSlot = (address, slot) =>
+  getSlot(address, slot).then(slotValue => ethers.AbiCoder.defaultAbiCoder().decode(['address'], slotValue)[0]);
+
+const upgradeableSlot = (contractName, offset) => {
+  try {
+    // Try to get the artifact paths, will throw if it doesn't exist
+    artifacts._getArtifactPathSync(`${contractName}Upgradeable`);
+    return offset + ethers.toBigInt(erc7201Slot(erc7201format(contractName)));
+  } catch {
+    return offset;
+  }
+};
+
+module.exports = {
+  ImplementationLabel,
+  AdminLabel,
+  BeaconLabel,
+  ImplementationSlot: erc1967Slot(ImplementationLabel),
+  AdminSlot: erc1967Slot(AdminLabel),
+  BeaconSlot: erc1967Slot(BeaconLabel),
+  erc1967Slot,
+  erc7201Slot,
+  erc7201format,
+  setSlot,
+  getSlot,
+  getAddressInSlot,
+  upgradeableSlot,
+};

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

@@ -0,0 +1,5 @@
+module.exports = {
+  // Capitalize the first char of a string
+  // Example: capitalize('uint256') → 'Uint256'
+  capitalize: str => str.charAt(0).toUpperCase() + str.slice(1),
+};

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

@@ -0,0 +1,33 @@
+const { ethers } = require('hardhat');
+const { time, mine, mineUpTo } = require('@nomicfoundation/hardhat-network-helpers');
+const { mapValues } = require('./iterate');
+
+const clock = {
+  blocknumber: () => time.latestBlock().then(ethers.toBigInt),
+  timestamp: () => time.latest().then(ethers.toBigInt),
+};
+const clockFromReceipt = {
+  blocknumber: receipt => Promise.resolve(receipt).then(({ blockNumber }) => ethers.toBigInt(blockNumber)),
+  timestamp: receipt =>
+    Promise.resolve(receipt)
+      .then(({ blockNumber }) => ethers.provider.getBlock(blockNumber))
+      .then(({ timestamp }) => ethers.toBigInt(timestamp)),
+};
+const increaseBy = {
+  blockNumber: mine,
+  timestamp: (delay, mine = true) =>
+    time.latest().then(clock => increaseTo.timestamp(clock + ethers.toNumber(delay), mine)),
+};
+const increaseTo = {
+  blocknumber: mineUpTo,
+  timestamp: (to, mine = true) => (mine ? time.increaseTo(to) : time.setNextBlockTimestamp(to)),
+};
+const duration = mapValues(time.duration, fn => n => ethers.toBigInt(fn(ethers.toNumber(n))));
+
+module.exports = {
+  clock,
+  clockFromReceipt,
+  increaseBy,
+  increaseTo,
+  duration,
+};