@layerzerolabs/onesig-evm 0.0.8 → 0.0.10

package/artifacts-zk/contracts/lib/SelfCallable.sol/SelfCallable.json

@@ -0,0 +1,17 @@
+{
+  "_format": "hh-zksolc-artifact-1",
+  "contractName": "SelfCallable",
+  "sourceName": "contracts/lib/SelfCallable.sol",
+  "abi": [
+    {
+      "inputs": [],
+      "name": "OnlySelfCall",
+      "type": "error"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "factoryDeps": {}
+}

package/contracts/ExecutorStore.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.8.22;
+
+import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import { SelfCallable } from "./lib/SelfCallable.sol";
+
+/**
+ * @title ExecutorStore
+ * @notice Abstract contract that manages a set of executors and a whether they are required.
+ * @dev Uses EnumerableSet to store executor addresses
+ */
+abstract contract ExecutorStore is SelfCallable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    /**
+     * @dev Set of available executors for the MultiSig.
+     */
+    EnumerableSet.AddressSet internal executorSet;
+
+    /**
+     * @notice Whether the executor permission is required to execute a transaction.
+     */
+    bool public executorRequired;
+
+    /// @notice Error thrown when an executor address is invalid.
+    /// @dev This error is thrown when the address is zero.
+    error InvalidExecutor();
+
+    /// @notice Error thrown when attempting to add an execute who is already active.
+    /// @param executor The address of the executor.
+    error ExecutorAlreadyActive(address executor);
+
+    /// @notice Error thrown when attempting to remove an execute who is not found.
+    /// @param executor The address of the executor.
+    error ExecutorNotFound(address executor);
+
+    /**
+     * @notice Emitted when an executor's active status is updated.
+     * @param executor The address of the executor.
+     * @param active True if added, false if removed.
+     */
+    event ExecutorSet(address indexed executor, bool active);
+
+    /**
+     * @notice Emitted when the executor required state is updated.
+     * @param required The new state
+     */
+    event ExecutorRequiredSet(bool required);
+
+    /**
+     * @dev Initializes the ExecutorStore with a list of executors and sets whether executors are required.
+     * @param _executors Array of executor addresses, can be empty.
+     * @dev If the array is empty, executorsRequired will be set to false.
+     */
+    constructor(address[] memory _executors, bool _executorRequired) {
+        for (uint256 i = 0; i < _executors.length; i++) {
+            _addExecutor(_executors[i]);
+        }
+        _setExecutorRequired(_executorRequired);
+    }
+
+    /**
+     * @dev Sets whether executors are required.
+     * @param _executorRequired The new threshold value.
+     */
+    function setExecutorRequired(bool _executorRequired) external onlySelfCall {
+        _setExecutorRequired(_executorRequired);
+    }
+
+    /**
+     * @dev Internal function to set whether executors are required for this MultiSig.
+     * @param _executorRequired The new value.
+     */
+    function _setExecutorRequired(bool _executorRequired) internal {
+        executorRequired = _executorRequired;
+        emit ExecutorRequiredSet(_executorRequired);
+    }
+
+    /**
+     * @notice Adds or removes an executor from this MultiSig.
+     * @dev Only callable via the MultiSig contract itself.
+     * @param _executor The address of the executor to add/remove.
+     * @param _active True to add executor, false to remove executor.
+     */
+    function setExecutor(address _executor, bool _active) external onlySelfCall {
+        if (_active) {
+            _addExecutor(_executor);
+        } else {
+            _removeExecutor(_executor);
+        }
+    }
+
+    /**
+     * @dev Internal function to add an executor.
+     * @param _executor The address of the executor to add.
+     */
+    function _addExecutor(address _executor) internal {
+        if (_executor == address(0)) revert InvalidExecutor();
+        if (!executorSet.add(_executor)) revert ExecutorAlreadyActive(_executor);
+        emit ExecutorSet(_executor, true);
+    }
+
+    /**
+     * @dev Internal function to remove an executor.
+     * @param _executor The address of the executor to remove.
+     */
+    function _removeExecutor(address _executor) internal {
+        if (!executorSet.remove(_executor)) revert ExecutorNotFound(_executor);
+        emit ExecutorSet(_executor, false);
+    }
+
+    /**
+     * @notice Returns the list of all active executors.
+     * @return An array of addresses representing the current set of executors.
+     */
+    function getExecutors() public view returns (address[] memory) {
+        return executorSet.values();
+    }
+
+    /**
+     * @notice Checks if a given address is in the set of executors.
+     * @param _executor The address to check.
+     * @return True if the address is a executor, otherwise false.
+     */
+    function isExecutor(address _executor) public view returns (bool) {
+        return executorSet.contains(_executor);
+    }
+
+    /**
+     * @notice Returns the total number of active executors.
+     * @return The number of executors currently active.
+     */
+    function totalExecutors() public view returns (uint256) {
+        return executorSet.length();
+    }
+}

package/contracts/MultiSig.sol

@@ -1,10 +1,10 @@
-// SPDX-License-Identifier: LZBL-1.2
-// TODO confirm the license
+// SPDX-License-Identifier: GPL-3.0
 
 pragma solidity ^0.8.22;
 
 import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import { SelfCallable } from "./lib/SelfCallable.sol";
 
 /**
  * @title MultiSig
@@ -12,7 +12,7 @@ import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableS
  *         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 {
+abstract contract MultiSig is SelfCallable {
     using EnumerableSet for EnumerableSet.AddressSet;
 
     /**
@@ -28,9 +28,6 @@ abstract contract MultiSig {
     /// @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();
 
@@ -58,7 +55,7 @@ abstract contract MultiSig {
      * @param signer The address of the signer.
      * @param active True if added, false if removed.
      */
-    event SignerSet(address signer, bool active);
+    event SignerSet(address indexed signer, bool active);
 
     /**
      * @notice Emitted when the threshold for signatures is set.
@@ -67,12 +64,9 @@ abstract contract MultiSig {
     event ThresholdSet(uint256 threshold);
 
     /**
-     * @dev Restricts access to functions so they can only be called via this contract itself.
+     * @dev The length of a single signature in bytes (r=32, s=32, v=1).
      */
-    modifier onlyMultiSig() {
-        if (msg.sender != address(this)) revert OnlyMultiSig();
-        _;
-    }
+    uint8 constant SIGNATURE_LENGTH = 65;
 
     /**
      * @dev Initializes the MultiSig with a list of signers and sets the signature threshold.
@@ -91,7 +85,7 @@ abstract contract MultiSig {
      * @dev This function can only be called by the MultiSig contract itself.
      * @param _threshold The new threshold value.
      */
-    function setThreshold(uint256 _threshold) external onlyMultiSig {
+    function setThreshold(uint256 _threshold) external onlySelfCall {
         _setThreshold(_threshold);
     }
 
@@ -115,7 +109,7 @@ abstract contract MultiSig {
      * @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 {
+    function setSigner(address _signer, bool _active) external onlySelfCall {
         if (_active) {
             _addSigner(_signer);
         } else {
@@ -172,22 +166,23 @@ abstract contract MultiSig {
      */
     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();
+        // Each signature is SIGNATURE_LENGTH (65) bytes (r=32, s=32, v=1).
+        if ((_signatures.length % SIGNATURE_LENGTH) != 0) revert SignatureError();
+        uint256 signaturesCount = _signatures.length / SIGNATURE_LENGTH;
+        if (signaturesCount < _threshold) 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];
+        for (uint256 i = 0; i < signaturesCount; i++) {
+            // Extract a single signature (SIGNATURE_LENGTH (65) bytes) at a time.
+            bytes calldata signature = _signatures[i * SIGNATURE_LENGTH:(i + 1) * SIGNATURE_LENGTH];
             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;
         }
     }

package/contracts/OneSig.sol

@@ -1,10 +1,11 @@
-// SPDX-License-Identifier: LZBL-1.2
-// TODO confirm the license
+// SPDX-License-Identifier: GPL-3.0
 
 pragma solidity ^0.8.22;
 
 import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+import { ReentrancyGuard } from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 import { MultiSig } from "./MultiSig.sol";
+import { ExecutorStore } from "./ExecutorStore.sol";
 
 /**
  * @title OneSig
@@ -14,7 +15,7 @@ import { MultiSig } from "./MultiSig.sol";
  *         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 {
+contract OneSig is MultiSig, ReentrancyGuard, ExecutorStore {
     /// @notice The version string of the OneSig contract.
     string public constant VERSION = "0.0.1";
 
@@ -47,7 +48,7 @@ contract OneSig is MultiSig {
             abi.encode(
                 EIP712DOMAIN_TYPE_HASH,
                 keccak256(bytes("OneSig")), // this contract name
-                keccak256(bytes("0.0.1")), // version
+                keccak256(bytes(VERSION)), // version
                 1, // Ethereum mainnet chainId
                 address(0xdEaD) // verifyingContract
             )
@@ -75,7 +76,7 @@ contract OneSig is MultiSig {
     /**
      * @notice A sequential nonce to prevent replay attacks and enforce transaction ordering.
      */
-    uint256 public nonce;
+    uint64 public nonce;
 
     /// @notice Emitted when the seed is updated.
     event SeedSet(bytes32 seed);
@@ -95,6 +96,9 @@ contract OneSig is MultiSig {
     /// @param index The index of the failing call within the transaction.
     error ExecutionFailed(uint256 index);
 
+    /// @notice Error thrown when a function is not called from an executor or signer.
+    error OnlyExecutorOrSigner();
+
     /**
      * @notice Call to be executed as part of a Transaction.calls.
      *  - OneSig -> [Arbitrary contract].
@@ -123,22 +127,40 @@ contract OneSig is MultiSig {
         bytes32[] proof;
     }
 
+    /**
+     * @dev Restricts access to functions so they can only be called via an executor, OR a multisig signer.
+     */
+    modifier onlyExecutorOrSigner() {
+        if (!canExecuteTransaction(msg.sender)) revert OnlyExecutorOrSigner();
+        _;
+    }
+
     /**
      * @notice Constructor to initialize the OneSig contract.
      * @dev Inherits MultiSig(_signers, _threshold).
+     * @param _executors The list of executors authorized to execute transactions.
      * @param _signers The list of signers authorized to sign transactions.
      * @param _threshold The initial threshold of signers required to execute a transaction.
      * @param _oneSigId A unique identifier per deployment, (typically block.chainid).
      * @param _seed The random seed to encode into the signatures/root.
      */
     constructor(
+        uint64 _oneSigId,
         address[] memory _signers,
         uint256 _threshold,
-        uint64 _oneSigId,
+        address[] memory _executors,
+        bool _executorRequired,
         bytes32 _seed
-    ) MultiSig(_signers, _threshold) {
+    ) MultiSig(_signers, _threshold) ExecutorStore(_executors, _executorRequired) {
         ONE_SIG_ID = _oneSigId;
+        _setSeed(_seed);
+    }
 
+    /**
+     * @notice Internal method to set the contract's seed.
+     * @param _seed The new seed value.
+     */
+    function _setSeed(bytes32 _seed) internal virtual {
         seed = _seed;
         emit SeedSet(_seed);
     }
@@ -148,9 +170,8 @@ contract OneSig is MultiSig {
      * @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);
+    function setSeed(bytes32 _seed) public virtual onlySelfCall {
+        _setSeed(_seed);
     }
 
     /**
@@ -167,7 +188,7 @@ contract OneSig is MultiSig {
         bytes32 _merkleRoot,
         uint256 _expiry,
         bytes calldata _signatures
-    ) external payable {
+    ) public payable virtual nonReentrant onlyExecutorOrSigner {
         // Verify the merkle root and signatures
         verifyMerkleRoot(_merkleRoot, _expiry, _signatures);
 
@@ -227,32 +248,38 @@ contract OneSig is MultiSig {
     }
 
     /**
-     * @notice Encodes the transaction leaf for inclusion in the merkle tree.
+     * @notice Double encodes the transaction leaf for inclusion in the merkle tree.
      * @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.
-         */
+    function encodeLeaf(uint64 _nonce, Call[] calldata _calls) public view returns (bytes32) {
         return
             keccak256(
                 abi.encodePacked(
-                    LEAF_ENCODING_VERSION,
-                    ONE_SIG_ID,
-                    bytes32(uint256(uint160(address(this)))), // convert address(this) into bytes32
-                    _nonce,
-                    abi.encode(_calls)
+                    keccak256(
+                        abi.encodePacked(
+                            LEAF_ENCODING_VERSION,
+                            ONE_SIG_ID,
+                            bytes32(uint256(uint160(address(this)))), // convert address(this) into bytes32
+                            _nonce,
+                            abi.encode(_calls)
+                        )
+                    )
                 )
             );
     }
 
+    /**
+     * @notice Checks if the a given address can execute a transaction.
+     * @param _sender The address of the message sender.
+     * @return True if executeTransaction can be called by the executor, otherwise false.
+     */
+    function canExecuteTransaction(address _sender) public view returns (bool) {
+        // If the flag is set to false, then ANYONE can execute permissionlessly, otherwise the msg.sender must be a executor, or a signer
+        return (!executorRequired || isExecutor(_sender) || isSigner(_sender));
+    }
+
     /**
      * @notice Fallback function to receive ether.
      * @dev Allows the contract to accept ETH.

package/contracts/lib/SelfCallable.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.8.22;
+
+abstract contract SelfCallable {
+    /// @notice Error thrown when attempting to call a function from an invalid address.
+    error OnlySelfCall();
+
+    /**
+     * @dev Restricts access to functions so they can only be called via this contract itself.
+     */
+    modifier onlySelfCall() {
+        if (msg.sender != address(this)) revert OnlySelfCall();
+        _;
+    }
+}

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@layerzerolabs/onesig-evm",
-  "version": "0.0.8",
-  "license": "MIT",
+  "version": "0.0.10",
+  "license": "GPL-3.0-only",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -11,6 +11,7 @@
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "contracts/**/*.sol",
     "artifacts/contracts/**/!(*.dbg).json",
@@ -34,7 +35,7 @@
   },
   "dependencies": {
     "ethers": "^5.7.2",
-    "@layerzerolabs/onesig-core": "0.0.7"
+    "@layerzerolabs/onesig-core": "0.0.8"
   },
   "devDependencies": {
     "@babel/core": "^7.23.9",
@@ -56,7 +57,7 @@
     "@typechain/hardhat": "^6.1.6",
     "@types/chai": "^4.3.11",
     "@types/mocha": "^10.0.6",
-    "@types/node": "~18.18.14",
+    "@types/node": "20.10.0",
     "chai": "~4.3.10",
     "chai-ethers": "^0.0.1",
     "dotenv": "^16.4.1",

package/typechain-types/@openzeppelin/contracts/utils/ReentrancyGuard.ts

@@ -0,0 +1,55 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { BaseContract, Signer, utils } from "ethers";
+
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface ReentrancyGuardInterface extends utils.Interface {
+  functions: {};
+
+  events: {};
+}
+
+export interface ReentrancyGuard extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ReentrancyGuardInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {};
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

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

@@ -3,3 +3,4 @@
 /* eslint-disable */
 import type * as cryptography from "./cryptography";
 export type { cryptography };
+export type { ReentrancyGuard } from "./ReentrancyGuard";