@coti-io/coti-contracts 1.2.0 → 1.3.1

package/contracts/pod/token/perc20/PodErc20Mintable.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "./PodERC20.sol";
+
+/// @title PodErc20Mintable
+/// @notice {PodERC20} variant that permits `mint` calls from a single immutable `minter` address.
+/// @dev The minter is set at construction and cannot change. To rotate minters, deploy a new token or subclass with
+///      a mutable `minter` plus access control. All other behavior (transfers, approvals, burns, syncing) is inherited
+///      verbatim from {PodERC20}.
+contract PodErc20Mintable is PodERC20 {
+    /// @notice Sole address allowed to call {PodERC20.mint} (encrypted or plain variant).
+    address public minter;
+    bool private _mintableInitialized;
+
+    /// @notice Thrown when a non-minter tries to mint; carries the caller for debugging.
+    error OnlyMinter(address caller);
+    /// @notice Mintable storage was already initialized.
+    error PodErc20MintableAlreadyInitialized();
+    /// @notice Minter was the zero address.
+    error PodErc20MintableInvalidMinter();
+
+    /**
+     * @param _minter Address authorized to mint; must not be zero.
+     * @param _cotiChainId See {PodERC20}.
+     * @param _inbox See {PodERC20}.
+     * @param _cotiSideContract See {PodERC20}.
+     * @param _name See {PodERC20}.
+     * @param _symbol See {PodERC20}.
+     */
+    constructor(
+        address _minter,
+        uint256 _cotiChainId,
+        address _inbox,
+        address _cotiSideContract,
+        string memory _name,
+        string memory _symbol
+    ) PodERC20(_cotiChainId, _inbox, _cotiSideContract, _name, _symbol) {
+        _initializeMintableMinter(_minter);
+    }
+
+    /// @inheritdoc PodERC20
+    /// @dev Allows the call only when `msg.sender == minter`; reverts with {OnlyMinter} otherwise.
+    function _checkMinter() internal view override {
+        if (msg.sender != minter) {
+            revert OnlyMinter(msg.sender);
+        }
+    }
+
+    /// @notice Initialize mintable token storage with default 18 decimals.
+    function _initializePodErc20Mintable(
+        address _minter,
+        uint256 _cotiChainId,
+        address _inbox,
+        address _cotiSideContract,
+        string memory _name,
+        string memory _symbol
+    ) internal {
+        _initializePodErc20Mintable(_minter, _cotiChainId, _inbox, _cotiSideContract, _name, _symbol, 18);
+    }
+
+    /// @notice Initialize mintable token storage with explicit decimals.
+    function _initializePodErc20Mintable(
+        address _minter,
+        uint256 _cotiChainId,
+        address _inbox,
+        address _cotiSideContract,
+        string memory _name,
+        string memory _symbol,
+        uint8 _decimals
+    ) internal {
+        _initializePodERC20(_cotiChainId, _inbox, _cotiSideContract, _name, _symbol, _decimals);
+        _initializeMintableMinter(_minter);
+    }
+
+    /// @notice Initialize the immutable-style minter slot for constructors and clones.
+    /// @param _minter Address authorized to mint; must not be zero.
+    function _initializeMintableMinter(address _minter) internal {
+        if (_mintableInitialized) {
+            revert PodErc20MintableAlreadyInitialized();
+        }
+        if (_minter == address(0)) {
+            revert PodErc20MintableInvalidMinter();
+        }
+        _mintableInitialized = true;
+        minter = _minter;
+    }
+}

package/contracts/pod/token/perc20/PodErc20MintableInitializable.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "./PodErc20Mintable.sol";
+
+/// @title PodErc20MintableInitializable
+/// @notice Clone-friendly {PodErc20Mintable}; the implementation constructor locks the implementation instance.
+/// @dev Usual deploy path is {PrivacyPortalFactory.createPortal} (clone + initialize in one tx).
+///      Split deploy-then-initialize is unsafe: an attacker can front-run `initialize` on an uninitialized clone.
+contract PodErc20MintableInitializable is PodErc20Mintable, Initializable {
+    /// @notice Lock the implementation instance with placeholder values.
+    constructor() PodErc20Mintable(address(1), 1, address(1), address(1), "IMPLEMENTATION", "IMPL") {
+        _disableInitializers();
+    }
+
+    /// @notice Initialize a mintable source-chain pToken clone.
+    /// @param _minter Address allowed to mint (the paired {PrivacyPortal}).
+    /// @param _owner Ownable admin allowed to {configure} inbox / COTI peer; factory passes `address(this)`.
+    /// @param _cotiChainId COTI chain id for remote MPC execution.
+    /// @param _inbox Source-chain inbox.
+    /// @param _cotiSideContract COTI-side pToken ledger.
+    /// @param _name Token name.
+    /// @param _symbol Token symbol.
+    /// @param _decimals Token decimals.
+    function initialize(
+        address _minter,
+        address _owner,
+        uint256 _cotiChainId,
+        address _inbox,
+        address _cotiSideContract,
+        string memory _name,
+        string memory _symbol,
+        uint8 _decimals
+    ) external initializer {
+        if (_owner == address(0)) {
+            revert PodERC20InvalidInitialization();
+        }
+        _initializePodErc20Mintable(_minter, _cotiChainId, _inbox, _cotiSideContract, _name, _symbol, _decimals);
+        _transferOwnership(_owner);
+    }
+}

package/contracts/pod/token/perc20/cotiside/IPodErc20CotiSide.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title IPodErc20CotiSide
+ * @notice Entry points the COTI inbox invokes for a paired {PodERC20}: balance/allowance ciphertext on-chain, MPC garbling in memory, and `respond`/`raise` wiring.
+ * @dev Implementations must restrict callers to the inbox and to the configured remote `PodERC20`. `transferFrom` does not carry
+ *      `msg.sender` as spender on this chain—allowance must be enforced before the cross-chain message is sent.
+ */
+interface IPodErc20CotiSide {
+    /**
+     * @notice Owner-only mint of plain `amount` into balance ciphertext storage for `to` (bridge / test setup).
+     * @dev Does not automatically update PoD ciphertext; use {syncBalances} on `PodERC20` after minting if mirrors must match.
+     *      Kept distinct from the inbox-called {mint} / {mintPublic} so `.selector` access stays unambiguous.
+     */
+    function ownerMint(address to, uint256 amount) external;
+
+    /**
+     * @notice Inbox-only mint with garbled `value`; responds with a {PodERC20.transferCallback}-shaped tuple so PoD updates `to`'s ciphertext.
+     */
+    function mint(address to, gtUint256 value) external;
+
+    /**
+     * @notice Inbox-only mint using a plain `amount`; COTI garbles via `MpcCore.setPublic256` and responds as in {mint}.
+     */
+    function mintPublic(address to, uint256 amount) external;
+
+    /**
+     * @notice For each account, `onBoard`s stored balance ciphertext, `offBoardToUser`s to that address, and `respond`s with `(addresses, amounts, nonce)`.
+     * @dev **Gotcha:** empty `accounts` should be rejected by the implementation; otherwise PoD may receive useless callbacks.
+     */
+    function syncBalances(address[] calldata accounts) external;
+
+    /**
+     * @notice Moves `value` garbled tokens from `from` to `to` if balance suffices, then `respond`s with the PoD transfer tuple.
+     * @dev **Gotcha:** locks on PoD are tracked separately; this function assumes the inbox message is well-formed.
+     */
+    function transfer(address from, address to, gtUint256 value) external;
+
+    /**
+     * @notice Plain-amount variant of {transfer}; COTI garbles via `MpcCore.setPublic256`.
+     */
+    function transferPublic(address from, address to, uint256 value) external;
+
+    /**
+     * @notice Legacy same MPC move as {transfer}; kept for compatibility with older PoD tokens.
+     * @dev New allowance-based integrations should use {transferFromAsSpender}.
+     */
+    function transferFrom(address from, address to, gtUint256 value) external;
+
+    /**
+     * @notice Legacy plain-amount variant of {transferFrom}; kept for compatibility with older PoD tokens.
+     */
+    function transferFromPublic(address from, address to, uint256 value) external;
+
+    /**
+     * @notice Spender-aware transferFrom that consumes allowance on COTI before moving garbled `value`.
+     */
+    function transferFromAsSpender(address spender, address from, address to, gtUint256 value) external;
+
+    /**
+     * @notice Plain-amount variant of {transferFromAsSpender}.
+     */
+    function transferFromPublicAsSpender(address spender, address from, address to, uint256 value) external;
+
+    /**
+     * @notice Sets garbled allowance and `respond`s with owner- and spender-specific ciphertext of the same allowance amount.
+     * @dev On invalid addresses the implementation should `raise` rather than revert if you need PoD `approveError` symmetry.
+     */
+    function approve(address tokenOwner, address spender, gtUint256 value) external;
+
+    /**
+     * @notice Plain-amount variant of {approve}; COTI garbles via `MpcCore.setPublic256`.
+     */
+    function approvePublic(address tokenOwner, address spender, uint256 value) external;
+
+    /**
+     * @notice Subtracts `value` from `from` and responds with a burn-shaped tuple (`to == 0`, zero ciphertexts for receiver side).
+     */
+    function burn(address from, gtUint256 value) external;
+
+    /**
+     * @notice Plain-amount variant of {burn}; COTI garbles via `MpcCore.setPublic256`.
+     */
+    function burnPublic(address from, uint256 value) external;
+}