@coti-io/coti-contracts 1.2.0 → 1.3.1

package/contracts/pod/mpc/PodLib64.sol

@@ -0,0 +1,385 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "../../utils/mpc/MpcCore.sol";
+
+import "../IInbox.sol";
+import "../mpccodec/MpcAbiCodec.sol";
+import "./coti-side/IPodExecutorOps.sol";
+import "./PodLibBase.sol";
+
+/// @title PodLib64
+/// @notice 64-bit POD MPC helpers (`itUint64` / `ctUint64`) and comparisons to `ctBool`.
+abstract contract PodLib64 is PodLibBase {
+    using MpcAbiCodec for MpcAbiCodec.MpcMethodCallContext;
+
+    function add64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.add64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function gt64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.gt64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function sub64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.sub64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function mul64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.mul64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    /// @notice Wrapping multiply modulo 2^64. Use only when downstream logic is defined over uint64 modular arithmetic.
+    function mulWrapping64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.mulWrapping64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function div64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.div64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function rem64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.rem64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function and64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.and64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function or64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.or64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function xor64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.xor64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function min64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.min64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function max64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.max64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function eq64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.eq64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function ne64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.ne64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function ge64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.ge64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function le64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.le64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function lt64(
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendThree(IPodExecutor64.lt64.selector, a, b, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei);
+    }
+
+    function mux64(
+        itBool memory bit,
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _forwardTwoWay(
+            _buildMpcMux64(bit, a, b, cOwner),
+            callbackSelector,
+            errorSelector,
+            totalValueWei,
+            callbackFeeLocalWei
+        );
+    }
+
+    function _buildMpcMux64(
+        itBool memory bit,
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner
+    ) private pure returns (IInbox.MpcMethodCall memory) {
+        return MpcAbiCodec.create(IPodExecutor64.mux64.selector, 4)
+            .addArgument(bit)
+            .addArgument(a)
+            .addArgument(b)
+            .addArgument(cOwner)
+            .build();
+    }
+
+    function shl64(
+        itUint64 memory a,
+        uint8 s,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendShift(
+            IPodExecutor64.shl64.selector, a, s, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei
+        );
+    }
+
+    function shr64(
+        itUint64 memory a,
+        uint8 s,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendShift(
+            IPodExecutor64.shr64.selector, a, s, cOwner, callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei
+        );
+    }
+
+    /// @dev Callback `data` is `abi.encode(uint256)` plaintext (executor decrypts MPC rand on COTI).
+    function rand64(
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _forwardTwoWay(
+            _buildMpcRand64(cOwner), callbackSelector, errorSelector, totalValueWei, callbackFeeLocalWei
+        );
+    }
+
+    function _buildMpcRand64(address cOwner) private pure returns (IInbox.MpcMethodCall memory) {
+        return MpcAbiCodec.create(IPodExecutor64.rand64.selector, 1).addArgument(cOwner).build();
+    }
+
+    /// @dev Callback `data` is `abi.encode(uint256)` plaintext.
+    function randBoundedBits64(
+        uint8 numBits,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _forwardTwoWay(
+            _buildMpcRandBoundedBits64(numBits, cOwner),
+            callbackSelector,
+            errorSelector,
+            totalValueWei,
+            callbackFeeLocalWei
+        );
+    }
+
+    function _buildMpcRandBoundedBits64(uint8 numBits, address cOwner)
+        private
+        pure
+        returns (IInbox.MpcMethodCall memory)
+    {
+        return MpcAbiCodec.create(IPodExecutor64.randBoundedBits64.selector, 2)
+            .addArgument(uint256(uint8(numBits)))
+            .addArgument(cOwner)
+            .build();
+    }
+
+    function _buildMpcThree64(bytes4 selector, itUint64 memory a, itUint64 memory b, address cOwner)
+        private
+        pure
+        returns (IInbox.MpcMethodCall memory)
+    {
+        return MpcAbiCodec.create(selector, 3).addArgument(a).addArgument(b).addArgument(cOwner).build();
+    }
+
+    function _buildMpcShift64(bytes4 selector, itUint64 memory a, uint8 s, address cOwner)
+        private
+        pure
+        returns (IInbox.MpcMethodCall memory)
+    {
+        return MpcAbiCodec.create(selector, 3)
+            .addArgument(a)
+            .addArgument(uint256(uint8(s)))
+            .addArgument(cOwner)
+            .build();
+    }
+
+    function _sendThree(
+        bytes4 selector,
+        itUint64 memory a,
+        itUint64 memory b,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) private returns (bytes32) {
+        return _forwardTwoWay(
+            _buildMpcThree64(selector, a, b, cOwner),
+            callbackSelector,
+            errorSelector,
+            totalValueWei,
+            callbackFeeLocalWei
+        );
+    }
+
+    function _sendShift(
+        bytes4 selector,
+        itUint64 memory a,
+        uint8 s,
+        address cOwner,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) private returns (bytes32) {
+        return _forwardTwoWay(
+            _buildMpcShift64(selector, a, s, cOwner),
+            callbackSelector,
+            errorSelector,
+            totalValueWei,
+            callbackFeeLocalWei
+        );
+    }
+}

package/contracts/pod/mpc/PodLibBase.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "../../utils/mpc/MpcCore.sol";
+
+import "../IInbox.sol";
+import "../mpccodec/MpcAbiCodec.sol";
+import "./PodUser.sol";
+
+/// @title PodLibBase
+/// @notice Shared POD helpers: fee-aware two-way sends and default outbox error surfacing.
+/// @dev Callers supply `totalValueWei` and `callbackFeeLocalWei`; the inbox splits into gas units. Not responsible for `tx.gasprice`.
+abstract contract PodLibBase is PodUser {
+    using MpcAbiCodec for MpcAbiCodec.MpcMethodCallContext;
+
+    constructor(address initialOwner) PodUser(initialOwner) {}
+
+    /// @dev Minimum callback slice in wei; inbox applies stricter policy from {InboxFeeManager}.
+    uint256 internal constant MIN_CALLBACK_FEE_WEI = 1;
+
+    /// @notice Accept native funds that can subsidize future inbox fees paid by inherited Pod helper methods.
+    /// @dev `_sendTwoWayWithFee` checks contract balance, so callers may pre-fund a Pod app and later spend that balance.
+    receive() external payable {}
+
+    /// @param totalValueWei Total native payment forwarded to `sendTwoWayMessage` (e.g. `msg.value`).
+    /// @param callbackFeeLocalWei Portion of that total reserved for the callback leg; caller-estimated.
+    function _sendTwoWayWithFee(
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei,
+        uint256 targetChainId_,
+        address targetContract_,
+        IInbox.MpcMethodCall memory mpcMethodCall,
+        bytes4 callbackSelector_,
+        bytes4 errorSelector_
+    ) internal returns (bytes32) {
+        require(callbackFeeLocalWei >= MIN_CALLBACK_FEE_WEI, "PodLib: callback fee min");
+        require(callbackFeeLocalWei <= totalValueWei, "PodLib: callback exceeds total");
+        require(address(this).balance >= totalValueWei, "PodLib: inbox fee");
+        return IInbox(inbox).sendTwoWayMessage{value: totalValueWei}(
+            targetChainId_,
+            targetContract_,
+            mpcMethodCall,
+            callbackSelector_,
+            errorSelector_,
+            callbackFeeLocalWei
+        );
+    }
+
+    /// @dev Splits stack between building `mpc` and forwarding; avoids "stack too deep" in codec helpers.
+    function _forwardTwoWay(
+        IInbox.MpcMethodCall memory mpc,
+        bytes4 callbackSelector,
+        bytes4 errorSelector,
+        uint256 totalValueWei,
+        uint256 callbackFeeLocalWei
+    ) internal returns (bytes32) {
+        return _sendTwoWayWithFee(
+            totalValueWei,
+            callbackFeeLocalWei,
+            cotiChainId,
+            mpcExecutorAddress,
+            mpc,
+            callbackSelector,
+            errorSelector
+        );
+    }
+
+    function onDefaultMpcError(bytes32 requestId) external onlyMpcExecutor {
+        (uint256 code, string memory message) = inbox.getOutboxError(requestId);
+        emit ErrorRemoteCall(requestId, code, message);
+    }
+}

package/contracts/pod/mpc/PodUser.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "../IInbox.sol";
+import "../InboxUser.sol";
+
+/// @title PodUser
+/// @notice POD base: COTI chain ID, MPC executor address, and owner-gated {configure}.
+abstract contract PodUser is InboxUser, Ownable {
+    /// @notice Default MPC error callback surfaced from the outbox.
+    event ErrorRemoteCall(bytes32 requestId, uint256 code, string message);
+
+    /// @notice Inbox callback remote sender did not match configured COTI MPC executor.
+    error OnlyMpcExecutor(uint256 remoteChainId, address remoteContract);
+
+    /// @notice COTI-side MPC executor target.
+    address internal mpcExecutorAddress = 0x0000000000000000000000000000000000000000;
+    /// @notice COTI chain id used for MPC requests.
+    uint256 internal cotiChainId = 2632500;
+
+    /// @param initialOwner Initial owner for configuration.
+    constructor(address initialOwner) Ownable(initialOwner) {}
+
+    /// @dev Internal COTI routing; use {configure} from outside this contract.
+    /// @param _mpcExecutorAddress COTI-side MPC executor address.
+    /// @param _cotiChainId COTI chain id.
+    function configureCoti(address _mpcExecutorAddress, uint256 _cotiChainId) internal virtual {
+        mpcExecutorAddress = _mpcExecutorAddress;
+        cotiChainId = _cotiChainId;
+    }
+
+    /// @notice Restrict a function to inbox callbacks from the configured COTI MPC executor.
+    /// @dev Reverts unless `msg.sender` is the inbox and the remote sender matches {cotiChainId} and {mpcExecutorAddress}.
+    ///      For callbacks that only need inbox verification, use {onlyInbox} from {InboxUser} instead.
+    modifier onlyMpcExecutor() {
+        if (msg.sender != address(inbox)) {
+            revert OnlyInbox(msg.sender);
+        }
+        (uint256 remoteChainId, address remoteContract) = inbox.inboxMsgSender();
+        if (remoteChainId != cotiChainId || remoteContract != mpcExecutorAddress) {
+            revert OnlyMpcExecutor(remoteChainId, remoteContract);
+        }
+        _;
+    }
+
+    /// @notice Owner-only: set inbox when `inbox_ != address(0)`; always updates COTI executor and chain id.
+    /// @param inbox_ New inbox address, or zero to leave the existing inbox unchanged.
+    /// @param mpcExecutor_ New COTI-side MPC executor address.
+    /// @param cotiChainId_ New COTI chain id.
+    function configure(address inbox_, address mpcExecutor_, uint256 cotiChainId_) external onlyOwner {
+        if (inbox_ != address(0)) {
+            setInbox(inbox_);
+        }
+        configureCoti(mpcExecutor_, cotiChainId_);
+    }
+}

package/contracts/pod/mpc/PodUserFuji.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "./PodUser.sol";
+import "../PodNetworkConstants.sol";
+
+/// @title PodUserFuji
+/// @notice PoD base for Avalanche Fuji source-chain dApps paired with COTI testnet.
+abstract contract PodUserFuji is PodUser {
+    constructor() {
+        setInbox(PodNetworkConstants.AVALANCHE_FUJI_INBOX);
+        configureCoti(PodNetworkConstants.COTI_TESTNET_MPC_EXECUTOR, PodNetworkConstants.COTI_TESTNET_CHAIN_ID);
+    }
+}

package/contracts/pod/mpc/PodUserSepolia.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "./PodUser.sol";
+import "../PodNetworkConstants.sol";
+
+/// @title PodUserSepolia
+abstract contract PodUserSepolia is PodUser {
+    constructor() {
+        setInbox(PodNetworkConstants.SEPOLIA_INBOX);
+        configureCoti(PodNetworkConstants.COTI_TESTNET_MPC_EXECUTOR, PodNetworkConstants.COTI_TESTNET_CHAIN_ID);
+    }
+}

package/contracts/pod/mpc/coti-side/IPodExecutorOps.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/// @title IPodExecutorOps
+/// @notice COTI-side MPC executor interfaces: 64-, 128-, and 256-bit operations with distinct selectors for {PodLib} dispatch.
+
+/// @notice 64-bit executor ops (distinct names for unambiguous `.selector` use in {PodLib64}).
+interface IPodExecutor64 {
+    function add64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function sub64(gtUint64 a, gtUint64 b, address cOwner) external;
+    /// @notice Checked multiplication. Reverts when the true product does not fit in uint64.
+    function mul64(gtUint64 a, gtUint64 b, address cOwner) external;
+    /// @notice Wrapping multiplication modulo 2^64. Use only when modulo arithmetic is an explicit invariant.
+    function mulWrapping64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function div64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function rem64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function and64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function or64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function xor64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function min64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function max64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function eq64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function ne64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function ge64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function gt64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function le64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function lt64(gtUint64 a, gtUint64 b, address cOwner) external;
+    function mux64(gtBool bit, gtUint64 a, gtUint64 b, address cOwner) external;
+    function shl64(gtUint64 a, uint8 s, address cOwner) external;
+    function shr64(gtUint64 a, uint8 s, address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint64`).
+    function rand64(address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint64`).
+    function randBoundedBits64(uint8 numBits, address cOwner) external;
+}
+
+/// @notice 128-bit executor ops.
+interface IPodExecutor128 {
+    function add128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function sub128(gtUint128 a, gtUint128 b, address cOwner) external;
+    /// @notice Checked multiplication. Reverts when the true product does not fit in uint128.
+    function mul128(gtUint128 a, gtUint128 b, address cOwner) external;
+    /// @notice Wrapping multiplication modulo 2^128. Use only when modulo arithmetic is an explicit invariant.
+    function mulWrapping128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function and128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function or128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function xor128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function min128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function max128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function eq128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function ne128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function ge128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function gt128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function le128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function lt128(gtUint128 a, gtUint128 b, address cOwner) external;
+    function mux128(gtBool bit, gtUint128 a, gtUint128 b, address cOwner) external;
+    function shl128(gtUint128 a, uint8 s, address cOwner) external;
+    function shr128(gtUint128 a, uint8 s, address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint128`).
+    function rand128(address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint128`).
+    function randBoundedBits128(uint8 numBits, address cOwner) external;
+}
+
+/// @notice 256-bit executor ops.
+interface IPodExecutor256 {
+    function add256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function sub256(gtUint256 a, gtUint256 b, address cOwner) external;
+    /// @notice Checked multiplication. Reverts when the true product does not fit in uint256.
+    function mul256(gtUint256 a, gtUint256 b, address cOwner) external;
+    /// @notice Wrapping multiplication modulo 2^256. Use only when modulo arithmetic is an explicit invariant.
+    function mulWrapping256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function and256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function or256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function xor256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function min256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function max256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function eq256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function ne256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function ge256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function gt256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function le256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function lt256(gtUint256 a, gtUint256 b, address cOwner) external;
+    function mux256(gtBool bit, gtUint256 a, gtUint256 b, address cOwner) external;
+    function shl256(gtUint256 a, uint8 s, address cOwner) external;
+    function shr256(gtUint256 a, uint8 s, address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint256`).
+    function rand256(address cOwner) external;
+
+    /// @notice Plaintext random; inbox payload is `abi.encode(uint256)` (not `ctUint256`).
+    function randBoundedBits256(uint8 numBits, address cOwner) external;
+}