@layerzerolabs/onesig-evm 0.0.2 → 0.0.4

package/contracts/MultiSig.sol

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: LZBL-1.2
+// TODO confirm the license
+
+pragma solidity ^0.8.22;
+
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+/**
+ * @title MultiSig
+ * @notice Abstract contract that manages a set of signers and a signature threshold.
+ *         Designed to be inherited by contracts requiring multi-signature verification.
+ * @dev Uses EnumerableSet to store signer addresses and ECDSA for signature recovery.
+ */
+abstract contract MultiSig {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    /**
+     * @dev Set of available signers for the MultiSig.
+     */
+    EnumerableSet.AddressSet internal signerSet;
+
+    /**
+     * @notice The number of signatures required to execute a transaction.
+     */
+    uint256 public threshold;
+
+    /// @notice Error thrown when a signer address is invalid.
+    error InvalidSigner();
+
+    /// @notice Error thrown when a function is not called from this contract itself.
+    error OnlyMultiSig();
+
+    /// @notice Error thrown when the threshold is set to zero.
+    error ZeroThreshold();
+
+    /// @notice Error thrown when the total number of signers is less than the threshold.
+    /// @param totalSigners The current number of signers.
+    /// @param threshold The required threshold.
+    error TotalSignersLessThanThreshold(uint256 totalSigners, uint256 threshold);
+
+    /// @notice Error thrown when attempting to add a signer who is already active.
+    /// @param signer The address of the signer.
+    error SignerAlreadyAdded(address signer);
+
+    /// @notice Error thrown when attempting to remove a signer who is not found.
+    /// @param signer The address of the signer.
+    error SignerNotFound(address signer);
+
+    /// @notice Error thrown when there is a signature format error or mismatch in length.
+    error SignatureError();
+
+    /// @notice Error thrown when signers are not sorted in ascending order (prevents duplicates).
+    error UnsortedSigners();
+
+    /**
+     * @notice Emitted when a signer's active status is updated.
+     * @param signer The address of the signer.
+     * @param active True if added, false if removed.
+     */
+    event SignerSet(address signer, bool active);
+
+    /**
+     * @notice Emitted when the threshold for signatures is set.
+     * @param threshold The new threshold.
+     */
+    event ThresholdSet(uint256 threshold);
+
+    /**
+     * @dev Restricts access to functions so they can only be called via this contract itself.
+     */
+    modifier onlyMultiSig() {
+        if (msg.sender != address(this)) revert OnlyMultiSig();
+        _;
+    }
+
+    /**
+     * @dev Initializes the MultiSig with a list of signers and sets the signature threshold.
+     * @param _signers Array of signer addresses.
+     * @param _threshold The initial threshold for signatures.
+     */
+    constructor(address[] memory _signers, uint256 _threshold) {
+        for (uint256 i = 0; i < _signers.length; i++) {
+            _addSigner(_signers[i]);
+        }
+        _setThreshold(_threshold);
+    }
+
+    /**
+     * @notice Allows the MultiSig contract to update the signature threshold.
+     * @dev This function can only be called by the MultiSig contract itself.
+     * @param _threshold The new threshold value.
+     */
+    function setThreshold(uint256 _threshold) external onlyMultiSig {
+        _setThreshold(_threshold);
+    }
+
+    /**
+     * @dev Internal function to set the threshold for this MultiSig.
+     *      - The threshold must be greater than zero.
+     *      - The threshold must be less than or equal to the number of signers.
+     * @param _threshold The new threshold value.
+     */
+    function _setThreshold(uint256 _threshold) internal {
+        if (_threshold == 0) revert ZeroThreshold();
+        if (totalSigners() < _threshold) revert TotalSignersLessThanThreshold(totalSigners(), _threshold);
+
+        threshold = _threshold;
+        emit ThresholdSet(_threshold);
+    }
+
+    /**
+     * @notice Adds or removes a signer from this MultiSig.
+     * @dev Only callable via the MultiSig contract itself.
+     * @param _signer The address of the signer to add/remove.
+     * @param _active True to add signer, false to remove signer.
+     */
+    function setSigner(address _signer, bool _active) external onlyMultiSig {
+        if (_active) {
+            _addSigner(_signer);
+        } else {
+            _removeSigner(_signer);
+        }
+    }
+
+    /**
+     * @dev Internal function to add a signer.
+     *      - `address(0)` is not a valid signer.
+     *      - A signer cannot be added twice.
+     * @param _signer The address of the signer to add.
+     */
+    function _addSigner(address _signer) internal {
+        if (_signer == address(0)) revert InvalidSigner();
+        if (!signerSet.add(_signer)) revert SignerAlreadyAdded(_signer);
+
+        emit SignerSet(_signer, true);
+    }
+
+    /**
+     * @dev Internal function to remove a signer.
+     *      - Signer must be part of the existing set of signers.
+     *      - The threshold must be less than or equal to the number of remaining signers.
+     * @param _signer The address of the signer to remove.
+     */
+    function _removeSigner(address _signer) internal {
+        if (!signerSet.remove(_signer)) revert SignerNotFound(_signer);
+        if (totalSigners() < threshold) revert TotalSignersLessThanThreshold(totalSigners(), threshold);
+
+        emit SignerSet(_signer, false);
+    }
+
+    /**
+     * @notice Verifies signatures on a given digest against the threshold.
+     * @dev Verifies that exactly `threshold` signatures are present, sorted by ascending signer addresses.
+     * @param _digest The message digest (hash) being signed.
+     * @param _signatures The concatenated signatures.
+     */
+    function verifySignatures(bytes32 _digest, bytes calldata _signatures) public view {
+        verifyNSignatures(_digest, _signatures, threshold);
+    }
+
+    /**
+     * @notice Verifies N signatures on a given digest.
+     * @dev Reverts if:
+     *       - The threshold passed is zero.
+     *       - The number of signatures doesn't match N (each signature is 65 bytes).
+     *       - The signers are not strictly increasing (to prevent duplicates).
+     *       - Any signer is not in the set of authorized signers.
+     * @param _digest The message digest (hash) being signed.
+     * @param _signatures The concatenated signatures.
+     * @param _threshold The required number of valid signatures.
+     */
+    function verifyNSignatures(bytes32 _digest, bytes calldata _signatures, uint256 _threshold) public view {
+        if (_threshold == 0) revert ZeroThreshold();
+        // Each signature is 65 bytes (r=32, s=32, v=1).
+        if (_signatures.length != _threshold * 65) revert SignatureError();
+
+        // There cannot be a signer with address 0, so we start with address(0) to ensure ascending order.
+        address lastSigner = address(0);
+
+        for (uint256 i = 0; i < _threshold; i++) {
+            // Extract a single signature (65 bytes) at a time.
+            bytes calldata signature = _signatures[i * 65:(i + 1) * 65];
+            address currentSigner = ECDSA.recover(_digest, signature);
+
+            // Check ordering to avoid duplicates and ensure strictly increasing addresses.
+            if (currentSigner <= lastSigner) revert UnsortedSigners();
+            // Check if the signer is in our set.
+            if (!isSigner(currentSigner)) revert SignerNotFound(currentSigner);
+
+            lastSigner = currentSigner;
+        }
+    }
+
+    /**
+     * @notice Returns the list of all active signers.
+     * @return An array of addresses representing the current set of signers.
+     */
+    function getSigners() public view returns (address[] memory) {
+        return signerSet.values();
+    }
+
+    /**
+     * @notice Checks if a given address is in the set of signers.
+     * @param _signer The address to check.
+     * @return True if the address is a signer, otherwise false.
+     */
+    function isSigner(address _signer) public view returns (bool) {
+        return signerSet.contains(_signer);
+    }
+
+    /**
+     * @notice Returns the total number of active signers.
+     * @return The number of signers currently active.
+     */
+    function totalSigners() public view returns (uint256) {
+        return signerSet.length();
+    }
+}

package/contracts/OneSig.sol

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: LZBL-1.2
+// TODO confirm the license
+
+pragma solidity ^0.8.22;
+
+import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+import { MultiSig } from "./MultiSig.sol";
+
+/**
+ * @title OneSig
+ * @author @TRileySchwarz, @Clearwood, @HansonYip, @mok-lz
+ * @notice A multi-chain enabled contract that uses a Merkle tree of transaction leaves.
+ *         It allows transactions to be signed once (off-chain) and then executed on multiple chains,
+ *         provided the Merkle proof is valid and the threshold of signers is met.
+ * @dev Inherits from MultiSig for signature threshold logic.
+ */
+contract OneSig is MultiSig {
+    /// @notice The version string of the OneSig contract.
+    string public constant VERSION = "0.0.1";
+
+    /**
+     * @dev EIP-191 defines the format of the signature prefix.
+     *      See https://eips.ethereum.org/EIPS/eip-191
+     */
+    string private constant EIP191_PREFIX_FOR_EIP712 = "\x19\x01";
+
+    /**
+     * @dev EIP-712 domain separator type-hash.
+     *      See https://eips.ethereum.org/EIPS/eip-712
+     */
+    bytes32 private constant EIP712DOMAIN_TYPE_HASH =
+        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
+
+    /**
+     * @dev This domain separator is used to generate a signature hash for the merkle root,
+     *      specifically using chainId = 1 (Ethereum Mainnet) and verifyingContract = 0xdEaD.
+     *      This ensures that the same merkle root signatures can be used across different chains
+     *      because they are all signed with this consistent "fake" domain.
+     *
+     *      In other words, to verify the merkle root with the same signatures on different chains,
+     *      we use the same chainId (1) and verifyingContract (0xdEaD) in the EIP-712 domain.
+     */
+    bytes32 private constant DOMAIN_SEPARATOR =
+        keccak256(
+            abi.encode(
+                EIP712DOMAIN_TYPE_HASH,
+                keccak256(bytes("OneSig")), // this contract name
+                keccak256(bytes("0.0.1")), // version
+                1, // Ethereum mainnet chainId
+                address(0xdEaD) // verifyingContract
+            )
+        );
+
+    /**
+     * @dev The type-hash of the data being signed to authorize a merkle root.
+     */
+    bytes32 private constant SIGN_MERKLE_ROOT_TYPE_HASH =
+        keccak256("SignMerkleRoot(bytes32 seed,bytes32 merkleRoot,uint256 expiry)");
+
+    /**
+     * @notice The chain ID of the contract.
+     * @dev Because the chainId is part of the leaf, the same signatures can be used on different chains.
+     *      Instead of signing a transaction per chain, we can sign a transaction once and execute it on multiple chains.
+     */
+    uint256 public immutable CHAIN_ID;
+
+    /**
+     * @notice A unique domain value for preventing replay attacks across different OneSig instances.
+     * @dev Computed as keccak256(abi.encode(_chainId, address(this))).
+     */
+    bytes32 private immutable TRANSACTION_DOMAIN;
+
+    /**
+     * @notice A random seed encoded into the signatures/root.
+     * @dev Allows for a previously signed, but unexecuted, transaction(s) to be 'revoked' by changing the seed.
+     */
+    bytes32 public seed;
+
+    /**
+     * @notice A sequential nonce to prevent replay attacks and enforce transaction ordering.
+     */
+    uint256 public nonce;
+
+    /// @notice Emitted when the seed is updated.
+    event SeedSet(bytes32 seed);
+
+    /// @notice Emitted when a transaction is executed.
+    /// @param merkleRoot The merkle root used to authorize the transaction.
+    /// @param nonce The nonce of the transaction.
+    event TransactionExecuted(bytes32 merkleRoot, uint256 nonce);
+
+    /// @notice Error thrown when a merkle proof is invalid or the nonce does not match the expected value.
+    error InvalidProofOrNonce();
+
+    /// @notice Error thrown when a merkle root has expired (past the _expiry timestamp).
+    error MerkleRootExpired();
+
+    /// @notice Error thrown when a call in the transaction array fails.
+    /// @param index The index of the failing call within the transaction.
+    error ExecutionFailed(uint256 index);
+
+    /**
+     * @notice Call to be executed as part of a Transaction.calls.
+     *  - OneSig -> [Arbitrary contract].
+     *  - e.g., setPeer(dstEid, remoteAddress).
+     * @param to Address of the contract for this data to be 'called' on.
+     * @param value Amount of ether to send with this call.
+     * @param data Encoded data to be sent to the contract (calldata).
+     */
+    struct Call {
+        address to;
+        uint256 value;
+        bytes data;
+    }
+
+    /**
+     * @notice Single call to the OneSig contract (address(this)).
+     *  - EOA -> OneSig
+     *  - This struct is 1:1 with a 'leaf' in the merkle tree.
+     *  - Execution of the underlying calls are atomic.
+     *  - Cannot be processed until the previous leaf (nonce-ordered) has been executed successfully.
+     * @param calls List of calls to be made.
+     * @param proof Merkle proof to verify the transaction.
+     */
+    struct Transaction {
+        Call[] calls;
+        bytes32[] proof;
+    }
+
+    /**
+     * @notice Constructor to initialize the OneSig contract.
+     * @dev Inherits MultiSig(_signers, _threshold).
+     * @param _signers The list of signers authorized to sign transactions.
+     * @param _threshold The initial threshold of signers required to execute a transaction.
+     * @param _chainId The chain ID of the contract (typically block.chainid).
+     * @param _seed The random seed to encode into the signatures/root.
+     */
+    constructor(
+        address[] memory _signers,
+        uint256 _threshold,
+        uint256 _chainId,
+        bytes32 _seed
+    ) MultiSig(_signers, _threshold) {
+        CHAIN_ID = _chainId;
+        TRANSACTION_DOMAIN = keccak256(abi.encode(_chainId, address(this)));
+
+        seed = _seed;
+        emit SeedSet(_seed);
+    }
+
+    /**
+     * @notice Sets the contract's seed.
+     * @dev Only callable via MultiSig functionality (i.e., requires threshold signatures from signers).
+     * @param _seed The new seed value.
+     */
+    function setSeed(bytes32 _seed) external onlyMultiSig {
+        seed = _seed;
+        emit SeedSet(_seed);
+    }
+
+    /**
+     * @notice Executes a single transaction (which corresponds to a leaf in the merkle tree) if valid signatures are provided.
+     * @dev '_transaction' corresponds 1:1 with a leaf. This function can be called by anyone (permissionless),
+     *      provided the merkle root is verified with sufficient signatures.
+     * @param _transaction The transaction data struct, including calls and proof.
+     * @param _merkleRoot The merkle root that authorizes this transaction.
+     * @param _expiry The timestamp after which the merkle root expires.
+     * @param _signatures Signatures from signers that meet the threshold.
+     */
+    function executeTransaction(
+        Transaction calldata _transaction,
+        bytes32 _merkleRoot,
+        uint256 _expiry,
+        bytes calldata _signatures
+    ) external payable {
+        // Verify the merkle root and signatures
+        verifyMerkleRoot(_merkleRoot, _expiry, _signatures);
+
+        // Verify that this transaction matches the merkle root (using its proof)
+        verifyTransactionProof(_merkleRoot, _transaction);
+
+        // Increment nonce before execution to prevent replay
+        uint256 n = nonce++;
+
+        // Execute all calls atomically
+        for (uint256 i = 0; i < _transaction.calls.length; i++) {
+            (bool success, ) = _transaction.calls[i].to.call{ value: _transaction.calls[i].value }(
+                _transaction.calls[i].data
+            );
+
+            // Revert if the call fails
+            if (!success) revert ExecutionFailed(i);
+        }
+
+        emit TransactionExecuted(_merkleRoot, n);
+    }
+
+    /**
+     * @notice Validates the signatures on a given merkle root.
+     * @dev Reverts if the merkle root is expired or signatures do not meet the threshold.
+     * @param _merkleRoot The merkle root to verify.
+     * @param _expiry The timestamp after which the merkle root becomes invalid.
+     * @param _signatures The provided signatures.
+     */
+    function verifyMerkleRoot(bytes32 _merkleRoot, uint256 _expiry, bytes calldata _signatures) public view {
+        // Check expiry
+        if (block.timestamp > _expiry) revert MerkleRootExpired();
+
+        // Compute the EIP-712 hash
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                EIP191_PREFIX_FOR_EIP712,
+                DOMAIN_SEPARATOR,
+                keccak256(abi.encode(SIGN_MERKLE_ROOT_TYPE_HASH, seed, _merkleRoot, _expiry))
+            )
+        );
+
+        // Verify the threshold signatures
+        verifySignatures(digest, _signatures);
+    }
+
+    /**
+     * @notice Verifies that the provided merkle proof matches the current transaction leaf under the merkle root.
+     * @dev Reverts if the proof is invalid or the nonce doesn't match the expected value.
+     * @param _merkleRoot The merkle root being used.
+     * @param _transaction The transaction data containing proof and calls.
+     */
+    function verifyTransactionProof(bytes32 _merkleRoot, Transaction calldata _transaction) public view {
+        bytes32 leaf = encodeLeaf(nonce, _transaction.calls);
+        bool valid = MerkleProof.verifyCalldata(_transaction.proof, _merkleRoot, leaf);
+        if (!valid) revert InvalidProofOrNonce();
+    }
+
+    /**
+     * @notice Encodes the transaction leaf for inclusion in the merkle tree.
+     * @dev Includes the chain-specific TRANSACTION_DOMAIN, the current nonce, and the calls array.
+     * @param _nonce The nonce of the transaction.
+     * @param _calls The calls to be made in this transaction.
+     * @return The keccak256 hash of the encoded leaf.
+     */
+    function encodeLeaf(uint256 _nonce, Call[] calldata _calls) public view returns (bytes32) {
+        /**
+         * The leaves here are NOT 64 bytes long, so they do not need to be double-encoded.
+         *
+         * The attack relies on being able to pass the preimage of the intermediate node
+         * (e.g., `a = h(l₁) + h(l₂)`, which is 64 bytes) as the leaf. Since this contract
+         * does not accept 64-byte leaves, it is impossible to supply a malicious leaf
+         * that matches the required format (`h(l₁) + h(l₂)`), thereby preventing the attack.
+         */
+        return keccak256(abi.encode(TRANSACTION_DOMAIN, _nonce, _calls));
+    }
+
+    /**
+     * @notice Fallback function to receive ether.
+     * @dev Allows the contract to accept ETH.
+     */
+    receive() external payable {}
+}

package/contracts/mocks/MockOApp.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.22;
+
+// A Mock contract for testing purposes
+contract MockOApp {
+    mapping(uint32 => bytes) public bytesMapping;
+
+    function setBytes(uint32 _dstEid, bytes calldata _bytes) public {
+        bytesMapping[_dstEid] = _bytes;
+    }
+
+    receive() external payable {}
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from 'ethers';
+import { BaseLeafData, GenerateLeafsResult } from '@layerzerolabs/onesig-core';
+
+interface ETHTransactionCallData {
+    to: string;
+    value: BigNumber;
+    data: string;
+}
+type ETHLeafData = BaseLeafData<string, ETHTransactionCallData>;
+declare function evmLeafGenerator(leafs: ETHLeafData[]): GenerateLeafsResult<ETHLeafData>;
+
+export { type ETHLeafData, evmLeafGenerator };

package/dist/index.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  evmLeafGenerator: () => evmLeafGenerator
+});
+module.exports = __toCommonJS(src_exports);
+var import_ethers = require("ethers");
+function evmLeafGenerator(leafs) {
+  return {
+    leafs,
+    encodeLeaf(tx) {
+      return import_ethers.ethers.utils.keccak256(
+        import_ethers.ethers.utils.defaultAbiCoder.encode(
+          [
+            "bytes32",
+            // hash(abi.encode(chainId, target), this is the unique key of the world for the leaf
+            "uint256",
+            // nonce
+            "tuple(address to, uint256 value, bytes data)[]"
+            // calls array
+          ],
+          [
+            import_ethers.ethers.utils.keccak256(
+              import_ethers.ethers.utils.defaultAbiCoder.encode(
+                ["uint256", "address"],
+                [tx.chainId, tx.targetOneSigAddress]
+              )
+            ),
+            tx.nonce,
+            tx.calls
+          ]
+        )
+      );
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/onesig-evm",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "license": "MIT",
   "exports": {
     ".": {
@@ -11,9 +11,11 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "contracts/**/*.sol",
     "artifacts/contracts/**/!(*.dbg).json",
     "artifacts-zk/contracts/**/!(*.dbg).json",
     "artifacts-tron/contracts/**/!(*.dbg).json",
+    "typechain-types/**/*",
     "dist/**/*"
   ],
   "lint-staged": {
@@ -29,6 +31,10 @@
       "pnpm solhint --fix --noPrompt"
     ]
   },
+  "dependencies": {
+    "ethers": "^5.7.2",
+    "@layerzerolabs/onesig-core": "0.0.4"
+  },
   "devDependencies": {
     "@babel/core": "^7.23.9",
     "@ethersproject/abstract-provider": "^5.7.0",
@@ -55,8 +61,6 @@
     "dotenv": "^16.4.1",
     "eslint": "^8.55.0",
     "eslint-plugin-jest-extended": "~2.0.0",
-    "ethers": "^5.7.2",
-    "fast-check": "^3.19.0",
     "hardhat": "~2.19.0",
     "hardhat-contract-sizer": "^2.10.0",
     "hardhat-deploy": "^0.12.4",
@@ -64,20 +68,15 @@
     "husky": "^8.0.3",
     "keccak256": "^1.0.6",
     "lint-staged": "^15.2.2",
-    "merkletreejs": "^0.3.11",
     "mocha": "^10.2.0",
-    "p-memoize": "~4.0.4",
     "prettier": "^3.2.5",
     "rimraf": "^5.0.5",
     "solhint": "^5.0.5",
     "solidity-bytes-utils": "^0.8.2",
     "solidity-coverage": "^0.8.12",
-    "ts-node": "^10.9.2",
-    "tsup": "~8.1.0",
     "typechain": "^8.3.2",
     "typescript": "^5.3.3",
-    "zod": "~3.23.8",
-    "@layerzerolabs/onesig-core": "0.0.2"
+    "zod": "~3.23.8"
   },
   "packageManager": "pnpm@8.14.0",
   "engines": {
@@ -87,8 +86,7 @@
     "access": "restricted"
   },
   "scripts": {
-    "build": "pnpm forge:build && pnpm hardhat:build && pnpm hardhat:build:tron && pnpm hardhat:build:zk",
-    "build:test": "pnpm build && pnpm test",
+    "build:js": "pnpm tsup",
     "clean": "pnpm clean:prebuild && rimraf cache out artifacts artifacts-zk artifacts-tron typechain-types",
     "clean:prebuild": "rimraf dist",
     "forge:build": "forge build",
@@ -98,10 +96,8 @@
     "hardhat:build:tron": "pnpm hardhat compile --network tron",
     "hardhat:build:zk": "pnpm hardhat compile --network zksync",
     "hardhat:test": "pnpm hardhat test",
-    "lint": "pnpm run lint:js && pnpm run lint:sol",
     "lint:fix": "eslint --fix '**/*.{js,ts,json}' && prettier --write . && solhint 'contracts/**/*.sol' --fix --noPrompt",
     "lint:js": "eslint '**/*.{js,ts,json}' && prettier --check .",
-    "lint:sol": "solhint 'contracts/**/*.sol'",
-    "test": "pnpm forge:test && pnpm hardhat:test"
+    "lint:sol": "solhint 'contracts/**/*.sol'"
   }
 }

package/typechain-types/@openzeppelin/contracts/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as utils from "./utils";
+export type { utils };