@enclave-e3/contracts 0.1.4 → 0.1.6

package/contracts/token/EnclaveTicketToken.sol

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+pragma solidity ^0.8.27;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {
+    SafeERC20
+} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {
+    ERC20Wrapper
+} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Wrapper.sol";
+import {
+    ERC20Permit
+} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
+import {
+    ERC20Votes
+} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { Nonces } from "@openzeppelin/contracts/utils/Nonces.sol";
+
+/**
+ * @title EnclaveTicketToken (ETK)
+ * @notice Non-transferable, non-delegatable ERC20Votes wrapper over a stablecoin for operator staking
+ * @dev ERC20 wrapper token that represents staked stablecoins (e.g., USDC, DAI) used for operator
+ *      bonding in the Enclave protocol. Implements voting power tracking through ERC20Votes but
+ *      prevents transfers between users and manual delegation. Deposits automatically delegate to
+ *      self to enable voting power tracking. Only the designated registry contract can mint
+ *      (deposit) and burn (withdraw) tokens.
+ */
+contract EnclaveTicketToken is
+    ERC20,
+    ERC20Permit,
+    ERC20Votes,
+    Ownable,
+    ERC20Wrapper
+{
+    using SafeERC20 for IERC20;
+    // Custom errors
+
+    /// @notice Thrown when a function is called by an address other than the registry
+    error NotRegistry();
+
+    /// @notice Thrown when attempting to transfer tokens between non-zero addresses
+    error TransferNotAllowed();
+
+    /// @notice Thrown when a zero address is provided where a valid address is required
+    error ZeroAddress();
+
+    /// @notice Thrown when attempting to manually delegate voting power
+    error DelegationLocked();
+
+    /// @notice Address of the registry contract authorized to mint, burn, and manage ticket tokens
+    /// @dev Only this contract can call restricted functions like depositFor, withdrawTo, burnTickets, and payout
+    address public registry;
+
+    /// @notice Restricts function access to only the registry contract
+    /// @dev Reverts with NotRegistry if caller is not the registry address
+    modifier onlyRegistry() {
+        if (msg.sender != registry) revert NotRegistry();
+        _;
+    }
+
+    /**
+     * @notice Initializes the Enclave Ticket Token with name "Enclave Ticket Token" and symbol "ETK"
+     * @dev Sets up the token as an ERC20 wrapper around the provided base token (stablecoin).
+     *      Initializes voting and permit functionality. The decimals will match the base token.
+     * @param baseToken The underlying ERC20 stablecoin to wrap (e.g., USDC, DAI)
+     * @param registry_ Address of the registry contract that will manage deposits and withdrawals
+     * @param initialOwner_ Address that will own the contract and can update the registry
+     */
+    constructor(
+        IERC20 baseToken,
+        address registry_,
+        address initialOwner_
+    )
+        ERC20("Enclave Ticket Token", "ETK")
+        ERC20Permit("Enclave Ticket Token")
+        ERC20Wrapper(baseToken)
+        Ownable(initialOwner_)
+    {
+        setRegistry(registry_);
+    }
+
+    /**
+     * @notice Updates the registry contract address
+     * @dev Only callable by the contract owner. The new registry address cannot be zero.
+     *      This function grants the new registry exclusive rights to mint, burn, and manage tokens.
+     * @param newRegistry Address of the new registry contract (must not be zero address)
+     */
+    function setRegistry(address newRegistry) public onlyOwner {
+        require(newRegistry != address(0), ZeroAddress());
+        registry = newRegistry;
+    }
+
+    /**
+     * @notice Deposits underlying tokens from the registry and mints ticket tokens to an operator
+     * @dev Only callable by the registry contract. Transfers underlying tokens from the registry to
+     *      this contract and mints an equivalent amount of ticket tokens. Automatically delegates
+     *      voting power to the operator on their first deposit to enable voting power tracking.
+     * @param operator Address to receive the minted ticket tokens
+     * @param amount Number of underlying tokens to deposit and ticket tokens to mint
+     * @return success True if the deposit and minting succeeded
+     */
+    function depositFor(
+        address operator,
+        uint256 amount
+    ) public override onlyRegistry returns (bool success) {
+        success = super.depositFor(operator, amount);
+
+        // Auto-delegate on first deposit to track voting power
+        if (delegates(operator) == address(0)) {
+            _delegate(operator, operator);
+        }
+    }
+
+    /**
+     * @notice Deposits underlying tokens from a specified account and mints ticket tokens to another account
+     * @dev Only callable by the registry contract. Transfers underlying tokens from the 'from' address
+     *      to this contract and mints ticket tokens to the 'to' address. Useful for scenarios where
+     *      the source and destination differ. Automatically delegates voting power to recipient on
+     *      their first deposit.
+     * @param from Address to transfer underlying tokens from (must have approved this contract)
+     * @param to Address to receive the minted ticket tokens
+     * @param amount Number of underlying tokens to deposit and ticket tokens to mint
+     * @return bool True if the deposit and minting succeeded
+     */
+    function depositFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) external onlyRegistry returns (bool) {
+        SafeERC20.safeTransferFrom(
+            IERC20(address(underlying())),
+            from,
+            address(this),
+            amount
+        );
+        _mint(to, amount);
+        if (delegates(to) == address(0)) _delegate(to, to);
+        return true;
+    }
+
+    /**
+     * @notice Burns ticket tokens from the registry and transfers underlying tokens to a receiver
+     * @dev Only callable by the registry contract. Burns ticket tokens from the registry's balance
+     *      and transfers an equivalent amount of underlying tokens to the receiver address. Used
+     *      when operators unstake their tokens.
+     * @param receiver Address to receive the underlying tokens
+     * @param amount Number of ticket tokens to burn and underlying tokens to transfer
+     * @return success True if the burn and transfer succeeded
+     */
+    function withdrawTo(
+        address receiver,
+        uint256 amount
+    ) public override onlyRegistry returns (bool success) {
+        return super.withdrawTo(receiver, amount);
+    }
+
+    /**
+     * @notice Burns ticket tokens from an operator's balance without transferring underlying tokens
+     * @dev Only callable by the registry contract. Used for slashing or penalizing operators where
+     *      the underlying tokens should remain in the contract or be handled separately. Does not
+     *      return underlying tokens to the operator.
+     * @param operator Address whose ticket tokens will be burned
+     * @param amount Number of ticket tokens to burn from the operator's balance
+     */
+    function burnTickets(
+        address operator,
+        uint256 amount
+    ) external onlyRegistry {
+        _burn(operator, amount);
+    }
+
+    /**
+     * @notice Transfer underlying tokens to an address without burning ticket tokens.
+     * @dev Only callable by the registry contract.
+     * @param to Address to payout to.
+     * @param amount Amount of ticket tokens to payout.
+     */
+    function payout(address to, uint256 amount) external onlyRegistry {
+        SafeERC20.safeTransfer(IERC20(address(underlying())), to, amount);
+    }
+
+    /**
+     * @dev Override ERC20Votes update hook to prevent transfers between users.
+     */
+    function _update(
+        address from,
+        address to,
+        uint256 value
+    ) internal override(ERC20, ERC20Votes) {
+        if (from != address(0) && to != address(0)) {
+            revert TransferNotAllowed();
+        }
+        super._update(from, to, value);
+    }
+
+    /**
+     * @dev Prevent delegation of voting power.
+     */
+    function delegate(address) public pure override {
+        revert DelegationLocked();
+    }
+
+    /**
+     * @dev Prevent delegation of voting power via signature.
+     */
+    function delegateBySig(
+        address,
+        uint256,
+        uint256,
+        uint8,
+        bytes32,
+        bytes32
+    ) public pure override {
+        revert DelegationLocked();
+    }
+
+    /**
+     * @dev Expose decimals from the underlying token.
+     */
+    function decimals()
+        public
+        view
+        override(ERC20, ERC20Wrapper)
+        returns (uint8)
+    {
+        return super.decimals();
+    }
+
+    /**
+     * @dev Expose permit nonces via both ERC20Permit and OpenZeppelin Nonces.
+     */
+    function nonces(
+        address owner
+    ) public view override(ERC20Permit, Nonces) returns (uint256) {
+        return super.nonces(owner);
+    }
+}

package/contracts/token/EnclaveToken.sol

@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+
+pragma solidity >=0.8.27;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {
+    ERC20Permit,
+    Nonces
+} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
+import {
+    ERC20Votes
+} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import {
+    AccessControl
+} from "@openzeppelin/contracts/access/AccessControl.sol";
+
+/**
+ * @title EnclaveToken
+ * @notice The governance and utility token for the Enclave protocol
+ * @dev ERC20 token with voting capabilities, permit functionality, and controlled minting.
+ *      Implements transfer restrictions that can be toggled by the owner to control token
+ *      transferability during early phases. Supports a maximum supply cap and role-based
+ *      minting through the MINTER_ROLE.
+ */
+contract EnclaveToken is
+    ERC20,
+    ERC20Permit,
+    ERC20Votes,
+    Ownable,
+    AccessControl
+{
+    // Custom errors
+
+    /// @notice Thrown when a zero address is provided where a valid address is required
+    error ZeroAddress();
+
+    /// @notice Thrown when attempting to mint zero tokens
+    error ZeroAmount();
+
+    /// @notice Thrown when minting would exceed the maximum token supply
+    error ExceedsTotalSupply();
+
+    /// @notice Thrown when array parameters have mismatched lengths
+    error ArrayLengthMismatch();
+
+    /// @notice Thrown when a transfer is attempted while restrictions are active and neither party is whitelisted
+    error TransferNotAllowed();
+
+    /// @notice Maximum supply of the token: 1.2 billion tokens with 18 decimals
+    /// @dev Hard cap on total token supply that cannot be exceeded through minting
+    uint256 public constant MAX_SUPPLY = 1_200_000_000e18;
+
+    /// @notice Role identifier for accounts authorized to mint new tokens
+    /// @dev Keccak256 hash of "MINTER_ROLE" used in AccessControl
+    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+
+    /// @notice Tracks the cumulative amount of tokens minted since deployment
+    /// @dev Incremented with each mint operation to enforce MAX_SUPPLY cap
+    uint256 public totalMinted;
+
+    /// @notice Mapping of addresses permitted to transfer tokens when restrictions are active
+    /// @dev When transfersRestricted is true, only whitelisted addresses can send or receive tokens
+    mapping(address account => bool allowed) public transferWhitelisted;
+
+    /// @notice Indicates whether token transfers are currently restricted
+    /// @dev When true, only whitelisted addresses can transfer tokens
+    bool public transfersRestricted;
+
+    /// @notice Emitted when tokens are minted as part of a named allocation
+    /// @param recipient Address receiving the minted tokens
+    /// @param amount Number of tokens minted (18 decimals)
+    /// @param allocation Description of the allocation for tracking purposes
+    event AllocationMinted(
+        address indexed recipient,
+        uint256 amount,
+        string allocation
+    );
+
+    /// @notice Emitted when the transfer restriction setting is changed
+    /// @param restricted New state of transfer restrictions (true = restricted, false = unrestricted)
+    event TransferRestrictionUpdated(bool restricted);
+
+    /// @notice Emitted when an address is added to or removed from the transfer whitelist
+    /// @param account Address whose whitelist status changed
+    /// @param whitelisted New whitelist status (true = whitelisted, false = not whitelisted)
+    event TransferWhitelistUpdated(address indexed account, bool whitelisted);
+
+    /**
+     * @notice Initializes the Enclave token with name "Enclave" and symbol "ENCL"
+     * @dev Sets up the token with voting and permit functionality. Grants admin and minter
+     *      roles to the owner, enables transfer restrictions, and whitelists the owner.
+     * @param _owner Address that will own the contract and receive DEFAULT_ADMIN_ROLE and MINTER_ROLE
+     */
+    constructor(
+        address _owner
+    ) ERC20("Enclave", "ENCL") ERC20Permit("Enclave") Ownable(_owner) {
+        // Grant the deployer all admin roles.
+        _grantRole(DEFAULT_ADMIN_ROLE, _owner);
+        _grantRole(MINTER_ROLE, _owner);
+
+        // Initialise state variables.
+        transfersRestricted = true;
+        transferWhitelisted[_owner] = true;
+
+        emit TransferRestrictionUpdated(true);
+        emit TransferWhitelistUpdated(_owner, true);
+    }
+
+    /**
+     * @notice Mints a named allocation of tokens to a specified recipient
+     * @dev Only callable by accounts with MINTER_ROLE. Reverts if recipient is zero address,
+     *      amount is zero, or minting would exceed MAX_SUPPLY. Updates totalMinted tracker.
+     * @param recipient Address to receive the minted tokens (cannot be zero address)
+     * @param amount Number of tokens to mint in wei (18 decimals, must be greater than zero)
+     * @param allocation Human-readable description of this allocation for tracking and auditing purposes
+     */
+    function mintAllocation(
+        address recipient,
+        uint256 amount,
+        string memory allocation
+    ) external onlyRole(MINTER_ROLE) {
+        if (recipient == address(0)) revert ZeroAddress();
+        if (amount == 0) revert ZeroAmount();
+        // Ensure we do not exceed the total supply.
+        if (totalMinted + amount > MAX_SUPPLY) revert ExceedsTotalSupply();
+
+        _mint(recipient, amount);
+        totalMinted += amount;
+        emit AllocationMinted(recipient, amount, allocation);
+    }
+
+    /**
+     * @notice Mints multiple named allocations to different recipients in a single transaction
+     * @dev Only callable by accounts with MINTER_ROLE. All arrays must have the same length.
+     *      Reverts if any amount is zero or if the cumulative minting would exceed MAX_SUPPLY.
+     *      Gas-efficient for distributing tokens to multiple addresses.
+     * @param recipients Array of addresses to receive minted tokens
+     * @param amounts Array of token amounts to mint (18 decimals, must match recipients length)
+     * @param allocations Array of allocation descriptions (must match recipients length)
+     */
+    function batchMintAllocations(
+        address[] calldata recipients,
+        uint256[] calldata amounts,
+        string[] calldata allocations
+    ) external onlyRole(MINTER_ROLE) {
+        uint256 len = recipients.length;
+        if (amounts.length != len || allocations.length != len) {
+            revert ArrayLengthMismatch();
+        }
+
+        uint256 minted = totalMinted;
+
+        for (uint256 i = 0; i < len; i++) {
+            address recipient = recipients[i];
+            uint256 amount = amounts[i];
+            if (amount == 0) revert ZeroAmount();
+
+            if (amount > MAX_SUPPLY - minted) revert ExceedsTotalSupply();
+            minted += amount;
+
+            _mint(recipient, amount);
+            emit AllocationMinted(recipient, amount, allocations[i]);
+        }
+
+        totalMinted = minted;
+    }
+
+    /**
+     * @notice Enables or disables transfer restrictions for the token
+     * @dev Only callable by the contract owner. When restrictions are enabled, only whitelisted
+     *      addresses can send or receive tokens. Useful for controlling token circulation during
+     *      early phases before public trading.
+     * @param restricted True to enable restrictions, false to allow unrestricted transfers
+     */
+    function setTransferRestriction(bool restricted) external onlyOwner {
+        transfersRestricted = restricted;
+        emit TransferRestrictionUpdated(restricted);
+    }
+
+    /**
+     * @notice Toggles an account's transfer whitelist status between enabled and disabled
+     * @dev Only callable by the contract owner. Flips the current whitelist state for the given
+     *      account. Whitelisted accounts can send and receive tokens even when transfer restrictions
+     *      are active.
+     * @param account Address whose whitelist status will be toggled
+     */
+    function toggleTransferWhitelist(address account) external onlyOwner {
+        bool newStatus = !transferWhitelisted[account];
+        transferWhitelisted[account] = newStatus;
+        emit TransferWhitelistUpdated(account, newStatus);
+    }
+
+    /**
+     * @notice Whitelists key protocol contracts to allow them to transfer tokens during restricted periods
+     * @dev Only callable by the contract owner. Convenience function for whitelisting multiple protocol
+     *      contracts in a single transaction. Zero addresses are safely ignored. Typically used to whitelist
+     *      contracts like bonding managers and vesting escrows that need to handle tokens on behalf of users.
+     * @param bondingManager Address of the BondingManager contract (zero address skipped)
+     * @param vestingEscrow Address of the VestingEscrow contract (zero address skipped)
+     */
+    function whitelistContracts(
+        address bondingManager,
+        address vestingEscrow
+    ) external onlyOwner {
+        if (bondingManager != address(0)) {
+            transferWhitelisted[bondingManager] = true;
+            emit TransferWhitelistUpdated(bondingManager, true);
+        }
+        if (vestingEscrow != address(0)) {
+            transferWhitelisted[vestingEscrow] = true;
+            emit TransferWhitelistUpdated(vestingEscrow, true);
+        }
+    }
+
+    /**
+     * @notice Internal hook that enforces transfer restrictions and updates voting power
+     * @dev Overrides ERC20 and ERC20Votes to add transfer restriction logic. Reverts if transfers
+     *      are restricted and neither sender nor receiver is whitelisted. Minting (from == 0) and
+     *      burning (to == 0) are always allowed regardless of restrictions.
+     * @param from Address sending tokens (zero address for minting)
+     * @param to Address receiving tokens (zero address for burning)
+     * @param value Amount of tokens being transferred
+     */
+    function _update(
+        address from,
+        address to,
+        uint256 value
+    ) internal override(ERC20, ERC20Votes) {
+        // When transfers are restricted, only whitelisted addresses can send or receive.
+        if (from != address(0) && to != address(0) && transfersRestricted) {
+            if (!transferWhitelisted[from] && !transferWhitelisted[to]) {
+                revert TransferNotAllowed();
+            }
+        }
+        super._update(from, to, value);
+    }
+
+    /**
+     * @notice Checks if this contract implements a given interface
+     * @dev Implements ERC165 interface detection via AccessControl
+     * @param interfaceId The interface identifier to check, as specified in ERC-165
+     * @return bool True if the contract implements the interface, false otherwise
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(AccessControl) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @notice Returns the current nonce for an address, used for permit signatures
+     * @dev Resolves the override conflict between ERC20Permit and Nonces by calling the parent
+     *      implementation. Nonces are incremented with each permit to prevent replay attacks.
+     * @param owner Address to query the nonce for
+     * @return uint256 The current nonce value for the given address
+     */
+    function nonces(
+        address owner
+    ) public view override(ERC20Permit, Nonces) returns (uint256) {
+        return super.nonces(owner);
+    }
+}

package/dist/hardhat.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hardhat.config.d.ts","sourceRoot":"","sources":["../hardhat.config.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA8ExD,QAAA,MAAM,MAAM,EAAE,iBAiFb,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"hardhat.config.d.ts","sourceRoot":"","sources":["../hardhat.config.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAoExD,QAAA,MAAM,MAAM,EAAE,iBA8Gb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/hardhat.config.js

@@ -8,15 +8,16 @@ import hardhatIgnitionEthers from "@nomicfoundation/hardhat-ignition-ethers";
 import hardhatNetworkHelpers from "@nomicfoundation/hardhat-network-helpers";
 import hardhatToolboxMochaEthersPlugin from "@nomicfoundation/hardhat-toolbox-mocha-ethers";
 import hardhatTypechainPlugin from "@nomicfoundation/hardhat-typechain";
+import hardhatVerify from "@nomicfoundation/hardhat-verify";
 import dotenv from "dotenv";
-import { ciphernodeAdd, ciphernodeRemove, ciphernodeSiblings, } from "./tasks/ciphernode";
+import { ciphernodeAdd, ciphernodeAdminAdd, ciphernodeMintTokens, ciphernodeRemove, ciphernodeSiblings, } from "./tasks/ciphernode";
 import { activateE3, enableE3, publishCiphertext, publishCommittee, publishInput, publishPlaintext, requestCommittee, } from "./tasks/enclave";
 import { cleanDeploymentsTask } from "./tasks/utils";
 dotenv.config();
 const mnemonic = process.env.MNEMONIC ??
     "test test test test test test test test test test test junk";
 const privateKey = process.env.PRIVATE_KEY;
-const infuraApiKey = process.env.INFURA_KEY;
+const rpcUrl = process.env.RPC_URL ?? "http://localhost:8545";
 const chainIds = {
     "arbitrum-mainnet": 42161,
     avalanche: 43114,
@@ -31,17 +32,6 @@ const chainIds = {
     goerli: 5,
 };
 function getChainConfig(chain, apiUrl) {
-    let jsonRpcUrl;
-    switch (chain) {
-        case "avalanche":
-            jsonRpcUrl = "https://api.avax.network/ext/bc/C/rpc";
-            break;
-        case "bsc":
-            jsonRpcUrl = "https://bsc-dataseed1.binance.org";
-            break;
-        default:
-            jsonRpcUrl = "https://" + chain + ".infura.io/v3/" + infuraApiKey;
-    }
     let accounts;
     if (privateKey) {
         accounts = [privateKey];
@@ -56,7 +46,7 @@ function getChainConfig(chain, apiUrl) {
     return {
         accounts,
         chainId: chainIds[chain],
-        url: jsonRpcUrl,
+        url: rpcUrl,
         type: "http",
         chainType: "l1",
         blockExplorers: {
@@ -73,9 +63,12 @@ const config = {
         hardhatNetworkHelpers,
         hardhatIgnitionEthers,
         hardhatEthersChaiMatchers,
+        hardhatVerify,
     ],
     tasks: [
         ciphernodeAdd,
+        ciphernodeAdminAdd,
+        ciphernodeMintTokens,
         ciphernodeRemove,
         ciphernodeSiblings,
         requestCommittee,
@@ -93,6 +86,16 @@ const config = {
             type: "edr-simulated",
             chainType: "l1",
         },
+        localhost: {
+            accounts: {
+                mnemonic,
+            },
+            chainId: chainIds.hardhat,
+            url: "http://localhost:8545",
+            type: "http",
+            chainType: "l1",
+            timeout: 60000,
+        },
         ganache: {
             accounts: {
                 mnemonic,
@@ -100,6 +103,7 @@ const config = {
             chainId: chainIds.ganache,
             url: "http://localhost:8545",
             type: "http",
+            timeout: 60000,
         },
         arbitrum: getChainConfig("arbitrum-mainnet", process.env.ARBISCAN_API_KEY || ""),
         avalanche: getChainConfig("avalanche", process.env.SNOWTRACE_API_KEY || ""),
@@ -111,6 +115,14 @@ const config = {
         sepolia: getChainConfig("sepolia", process.env.ETHERSCAN_API_KEY || ""),
         goerli: getChainConfig("goerli", process.env.ETHERSCAN_API_KEY || ""),
     },
+    verify: {
+        etherscan: {
+            apiKey: process.env.ETHERSCAN_API_KEY || "",
+        },
+        blockscout: {
+            enabled: false,
+        },
+    },
     paths: {
         artifacts: "./artifacts",
         cache: "./cache",
@@ -122,15 +134,22 @@ const config = {
         tsNocheck: false,
     },
     solidity: {
-        npmFilesToBuild: ["poseidon-solidity/PoseidonT3.sol"],
+        npmFilesToBuild: [
+            "poseidon-solidity/PoseidonT3.sol",
+            "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol",
+            "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol",
+        ],
         compilers: [
             {
-                version: "0.8.27",
+                version: "0.8.28",
                 settings: {
                     optimizer: {
                         enabled: true,
                         runs: 800,
                     },
+                    metadata: {
+                        bytecodeHash: "none",
+                    },
                 },
             },
         ],

package/dist/ignition/modules/{mockInputValidator.d.ts → bondingRegistry.d.ts}

@@ -1,3 +1,3 @@
 declare const _default: any;
 export default _default;
-//# sourceMappingURL=mockInputValidator.d.ts.map
+//# sourceMappingURL=bondingRegistry.d.ts.map

package/dist/ignition/modules/bondingRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bondingRegistry.d.ts","sourceRoot":"","sources":["../../../ignition/modules/bondingRegistry.ts"],"names":[],"mappings":"wBAuCM,GAAG;AAhCT,wBAgCU"}

package/dist/ignition/modules/bondingRegistry.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
+export default buildModule("BondingRegistry", (m) => {
+    const ticketToken = m.getParameter("ticketToken");
+    const licenseToken = m.getParameter("licenseToken");
+    const registry = m.getParameter("registry");
+    const slashedFundsTreasury = m.getParameter("slashedFundsTreasury");
+    const ticketPrice = m.getParameter("ticketPrice");
+    const licenseRequiredBond = m.getParameter("licenseRequiredBond");
+    const minTicketBalance = m.getParameter("minTicketBalance");
+    const exitDelay = m.getParameter("exitDelay");
+    const owner = m.getParameter("owner");
+    const bondingRegistryImpl = m.contract("BondingRegistry", []);
+    const initData = m.encodeFunctionCall(bondingRegistryImpl, "initialize", [
+        owner,
+        ticketToken,
+        licenseToken,
+        registry,
+        slashedFundsTreasury,
+        ticketPrice,
+        licenseRequiredBond,
+        minTicketBalance,
+        exitDelay,
+    ]);
+    const bondingRegistry = m.contract("TransparentUpgradeableProxy", [
+        bondingRegistryImpl,
+        owner,
+        initData,
+    ]);
+    return { bondingRegistry };
+});

package/dist/ignition/modules/ciphernodeRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ciphernodeRegistry.d.ts","sourceRoot":"","sources":["../../../ignition/modules/ciphernodeRegistry.ts"],"names":[],"mappings":"wBA0BM,GAAG;AAjBT,wBAiBU"}
+{"version":3,"file":"ciphernodeRegistry.d.ts","sourceRoot":"","sources":["../../../ignition/modules/ciphernodeRegistry.ts"],"names":[],"mappings":"wBAiCM,GAAG;AA1BT,wBA0BU"}