@layerzerolabs/onesig-evm 0.0.9 → 0.0.11

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

@@ -55,7 +55,7 @@ abstract contract MultiSig is SelfCallable {
      * @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.

package/contracts/OneSig.sol

@@ -5,6 +5,7 @@ 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, ReentrancyGuard {
+contract OneSig is MultiSig, ReentrancyGuard, ExecutorStore {
     /// @notice The version string of the OneSig contract.
     string public constant VERSION = "0.0.1";
 
@@ -95,6 +96,9 @@ contract OneSig is MultiSig, ReentrancyGuard {
     /// @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,20 +127,32 @@ contract OneSig is MultiSig, ReentrancyGuard {
         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 _oneSigId A unique identifier per deployment, (typically block.chainid).
      * @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 _executors The list of executors authorized to execute transactions.
+     * @param _executorRequired If executors are required to execute transactions.
      * @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);
     }
@@ -151,7 +167,7 @@ contract OneSig is MultiSig, ReentrancyGuard {
     }
 
     /**
-     * @notice External method to set the contract's 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.
      */
@@ -173,7 +189,7 @@ contract OneSig is MultiSig, ReentrancyGuard {
         bytes32 _merkleRoot,
         uint256 _expiry,
         bytes calldata _signatures
-    ) public payable virtual nonReentrant {
+    ) public payable virtual nonReentrant onlyExecutorOrSigner {
         // Verify the merkle root and signatures
         verifyMerkleRoot(_merkleRoot, _expiry, _signatures);
 
@@ -255,6 +271,16 @@ contract OneSig is MultiSig, ReentrancyGuard {
             );
     }
 
+    /**
+     * @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/dist/index.d.mts

@@ -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.mjs

@@ -0,0 +1,20 @@
+// src/index.ts
+import { ethers } from "ethers";
+function evmLeafGenerator(leafs) {
+  return {
+    leafs,
+    encodeAddress(address) {
+      return Buffer.from(address.substring(2).padStart(64, "0"), "hex");
+    },
+    encodeCalls(calls) {
+      const hexString = ethers.utils.defaultAbiCoder.encode(
+        ["tuple(address to, uint256 value, bytes data)[]"],
+        [calls]
+      );
+      return Buffer.from(hexString.substring(2), "hex");
+    }
+  };
+}
+export {
+  evmLeafGenerator
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/onesig-evm",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "license": "GPL-3.0-only",
   "exports": {
     ".": {
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "ethers": "^5.7.2",
-    "@layerzerolabs/onesig-core": "0.0.8"
+    "@layerzerolabs/onesig-core": "0.0.9"
   },
   "devDependencies": {
     "@babel/core": "^7.23.9",
@@ -88,7 +88,7 @@
     "access": "restricted"
   },
   "scripts": {
-    "build:js": "pnpm tsup",
+    "build:js": "pnpm tsup --config ../../tsup.config.ts ./src/index.ts",
     "clean": "pnpm clean:prebuild && rimraf cache out artifacts artifacts-zk artifacts-tron typechain-types",
     "clean:prebuild": "rimraf dist",
     "forge:build": "forge build",

package/typechain-types/contracts/ExecutorStore.ts

@@ -0,0 +1,286 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../common";
+
+export interface ExecutorStoreInterface extends utils.Interface {
+  functions: {
+    "executorRequired()": FunctionFragment;
+    "getExecutors()": FunctionFragment;
+    "isExecutor(address)": FunctionFragment;
+    "setExecutor(address,bool)": FunctionFragment;
+    "setExecutorRequired(bool)": FunctionFragment;
+    "totalExecutors()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "executorRequired"
+      | "getExecutors"
+      | "isExecutor"
+      | "setExecutor"
+      | "setExecutorRequired"
+      | "totalExecutors"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "executorRequired",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getExecutors",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isExecutor",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setExecutor",
+    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setExecutorRequired",
+    values: [PromiseOrValue<boolean>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalExecutors",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "executorRequired",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getExecutors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isExecutor", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setExecutor",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setExecutorRequired",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalExecutors",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "ExecutorRequiredSet(bool)": EventFragment;
+    "ExecutorSet(address,bool)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "ExecutorRequiredSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ExecutorSet"): EventFragment;
+}
+
+export interface ExecutorRequiredSetEventObject {
+  required: boolean;
+}
+export type ExecutorRequiredSetEvent = TypedEvent<
+  [boolean],
+  ExecutorRequiredSetEventObject
+>;
+
+export type ExecutorRequiredSetEventFilter =
+  TypedEventFilter<ExecutorRequiredSetEvent>;
+
+export interface ExecutorSetEventObject {
+  executor: string;
+  active: boolean;
+}
+export type ExecutorSetEvent = TypedEvent<
+  [string, boolean],
+  ExecutorSetEventObject
+>;
+
+export type ExecutorSetEventFilter = TypedEventFilter<ExecutorSetEvent>;
+
+export interface ExecutorStore extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ExecutorStoreInterface;
+
+  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: {
+    executorRequired(overrides?: CallOverrides): Promise<[boolean]>;
+
+    getExecutors(overrides?: CallOverrides): Promise<[string[]]>;
+
+    isExecutor(
+      _executor: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    setExecutor(
+      _executor: PromiseOrValue<string>,
+      _active: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setExecutorRequired(
+      _executorRequired: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    totalExecutors(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  executorRequired(overrides?: CallOverrides): Promise<boolean>;
+
+  getExecutors(overrides?: CallOverrides): Promise<string[]>;
+
+  isExecutor(
+    _executor: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  setExecutor(
+    _executor: PromiseOrValue<string>,
+    _active: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setExecutorRequired(
+    _executorRequired: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  totalExecutors(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    executorRequired(overrides?: CallOverrides): Promise<boolean>;
+
+    getExecutors(overrides?: CallOverrides): Promise<string[]>;
+
+    isExecutor(
+      _executor: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    setExecutor(
+      _executor: PromiseOrValue<string>,
+      _active: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setExecutorRequired(
+      _executorRequired: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    totalExecutors(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "ExecutorRequiredSet(bool)"(
+      required?: null
+    ): ExecutorRequiredSetEventFilter;
+    ExecutorRequiredSet(required?: null): ExecutorRequiredSetEventFilter;
+
+    "ExecutorSet(address,bool)"(
+      executor?: PromiseOrValue<string> | null,
+      active?: null
+    ): ExecutorSetEventFilter;
+    ExecutorSet(
+      executor?: PromiseOrValue<string> | null,
+      active?: null
+    ): ExecutorSetEventFilter;
+  };
+
+  estimateGas: {
+    executorRequired(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getExecutors(overrides?: CallOverrides): Promise<BigNumber>;
+
+    isExecutor(
+      _executor: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    setExecutor(
+      _executor: PromiseOrValue<string>,
+      _active: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setExecutorRequired(
+      _executorRequired: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    totalExecutors(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    executorRequired(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getExecutors(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    isExecutor(
+      _executor: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    setExecutor(
+      _executor: PromiseOrValue<string>,
+      _active: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setExecutorRequired(
+      _executorRequired: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    totalExecutors(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/contracts/MultiSig.ts

@@ -273,10 +273,13 @@ export interface MultiSig extends BaseContract {
 
   filters: {
     "SignerSet(address,bool)"(
-      signer?: null,
+      signer?: PromiseOrValue<string> | null,
+      active?: null
+    ): SignerSetEventFilter;
+    SignerSet(
+      signer?: PromiseOrValue<string> | null,
       active?: null
     ): SignerSetEventFilter;
-    SignerSet(signer?: null, active?: null): SignerSetEventFilter;
 
     "ThresholdSet(uint256)"(threshold?: null): ThresholdSetEventFilter;
     ThresholdSet(threshold?: null): ThresholdSetEventFilter;