@rootzero/contracts 1.22.0 → 1.23.0

package/commands/admin/Unauthorize.sol

@@ -22,21 +22,19 @@ abstract contract Unauthorize is AdminBase {
     }
 
     /// @notice Unauthorize each NODE block in the admin input.
-    /// @param input NODE block stream.
+    /// @param context Admin command context carrying the NODE input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function unauthorize(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             uint node = exec.unpackNode(Lanes.Input);
             setNode(node, false);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/core/Calls.sol

@@ -3,6 +3,9 @@ pragma solidity ^0.8.33;
 
 import {TrustAccess} from "./Access.sol";
 import {Nodes} from "../utils/Nodes.sol";
+import {Keys} from "../codec/Keys.sol";
+import {Sizes} from "../codec/Specs.sol";
+import {max32} from "../utils/Utils.sol";
 
 /// @dev Emitted when a trusted inter-node call fails.
 /// @param addr Contract address that was called.
@@ -81,6 +84,50 @@ abstract contract NodeCalls is RawNodeCalls, TrustAccess {
 /// @title CommandCalls
 /// @notice Trusted command-call helpers for contracts that route command nodes.
 abstract contract CommandCalls is NodeCalls {
+    /// @dev Build `command(bytes)` calldata and its nested CONTEXT block in one allocation.
+    /// Threaded state is copied from memory and step input directly from calldata.
+    function encodeCommandCall(
+        bytes4 selector,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input
+    ) internal pure returns (bytes memory data) {
+        uint contextLen = max32(Sizes.B32 + 2 * Sizes.Header + state.length + input.length);
+        uint paddedContextLen = (contextLen + 31) & ~uint(31);
+        uint dataLen = 4 + 64 + paddedContextLen;
+
+        // Reserve one scratch word because the final eight-byte block header is
+        // written with mstore. Exclude that word from the returned calldata.
+        data = new bytes(dataLen + 32);
+
+        uint contextKey = uint32(Keys.Context);
+        uint bytesKey = uint32(Keys.Bytes);
+        assembly ("memory-safe") {
+            mstore(data, dataLen)
+            let out := add(data, 0x20)
+
+            // ABI envelope for command(bytes).
+            mstore(out, selector)
+            mstore(add(out, 0x04), 0x20)
+            mstore(add(out, 0x24), contextLen)
+
+            // CONTEXT(account, BYTES(state), BYTES(input)).
+            let context := add(out, 0x44)
+            mstore(context, or(shl(224, contextKey), shl(192, sub(contextLen, 8))))
+            mstore(add(context, 0x08), account)
+
+            let stateBlock := add(context, 0x28)
+            let stateLen := mload(state)
+            mstore(stateBlock, or(shl(224, bytesKey), shl(192, stateLen)))
+            mcopy(add(stateBlock, 0x08), add(state, 0x20), stateLen)
+
+            let inputBlock := add(add(stateBlock, 0x08), stateLen)
+            let inputLen := input.length
+            mstore(inputBlock, or(shl(224, bytesKey), shl(192, inputLen)))
+            calldatacopy(add(inputBlock, 0x08), input.offset, inputLen)
+        }
+    }
+
     /// @notice Encode and call a trusted command node.
     /// @param command Command node ID embedding the target selector.
     /// @param value Native value to forward in wei.
@@ -97,7 +144,7 @@ abstract contract CommandCalls is NodeCalls {
         bytes calldata input
     ) internal returns (bytes memory nextState, bytes memory transactions) {
         bytes4 selector = Nodes.commandSelector(command);
-        bytes memory data = abi.encodeWithSelector(selector, account, state, input);
+        bytes memory data = encodeCommandCall(selector, account, state, input);
         return abi.decode(trustedCall(command, value, data), (bytes, bytes));
     }
 }
@@ -110,7 +157,18 @@ abstract contract PortCalls is NodeCalls {
     /// @param value Native value to forward in wei.
     /// @param input Port input block stream.
     /// @return success True if the low-level port call succeeded.
-    function tryCallPort(uint port, uint128 value, bytes calldata input) internal returns (bool success) {
+    function tryCallPort(uint port, uint128 value, bytes memory input) internal returns (bool success) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return tryTrustedCall(port, value, data);
+    }
+
+    /// @notice Try to encode and call a trusted port node by copying input from calldata.
+    /// @param port Port node ID embedding the target selector.
+    /// @param value Native value to forward in wei.
+    /// @param input Port input block stream.
+    /// @return success True if the low-level port call succeeded.
+    function tryCallPortCopy(uint port, uint128 value, bytes calldata input) internal returns (bool success) {
         bytes4 selector = Nodes.portSelector(port);
         bytes memory data = abi.encodeWithSelector(selector, input);
         return tryTrustedCall(port, value, data);
@@ -121,7 +179,18 @@ abstract contract PortCalls is NodeCalls {
     /// @param value Native value to forward in wei.
     /// @param input Port input block stream.
     /// @return Decoded port output block stream.
-    function callPort(uint port, uint128 value, bytes calldata input) internal returns (bytes memory) {
+    function callPort(uint port, uint128 value, bytes memory input) internal returns (bytes memory) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return abi.decode(trustedCall(port, value, data), (bytes));
+    }
+
+    /// @notice Encode and call a trusted port node by copying input from calldata.
+    /// @param port Port node ID embedding the target selector.
+    /// @param value Native value to forward in wei.
+    /// @param input Port input block stream.
+    /// @return Decoded port output block stream.
+    function callPortCopy(uint port, uint128 value, bytes calldata input) internal returns (bytes memory) {
         bytes4 selector = Nodes.portSelector(port);
         bytes memory data = abi.encodeWithSelector(selector, input);
         return abi.decode(trustedCall(port, value, data), (bytes));

package/core/Portal.sol

@@ -21,7 +21,7 @@ abstract contract Portal is PortCalls, NodeAccess, UnresolvedEvent, ResolvedEven
     /// @param value Native EVM value assigned to the forwarding attempt.
     /// @return miss Message digest recorded for recovery when forwarding fails; zero on success.
     function forward(uint port, bytes32 key, bytes calldata message, uint128 value) internal returns (bytes32 miss) {
-        if (tryCallPort(port, value, message)) return bytes32(0);
+        if (tryCallPortCopy(port, value, message)) return bytes32(0);
 
         miss = keccak256(message);
         unresolved[key] = miss;
@@ -37,6 +37,6 @@ abstract contract Portal is PortCalls, NodeAccess, UnresolvedEvent, ResolvedEven
         if (unresolved[key] != keccak256(witness)) revert BadWitness();
 
         delete unresolved[key];
-        callPort(port, value, witness);
+        callPortCopy(port, value, witness);
     }
 }

package/events/Positioned.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted when an action produces an account position.
+abstract contract PositionedEvent is EventEmitter {
+    string private constant ABI =
+        "event Positioned(bytes32 indexed account, bytes32 asset, uint amount, bytes32 liability, uint debt, uint32 action)";
+
+    /// @param account Account associated with the position.
+    /// @param asset Identifier for the asset side.
+    /// @param amount Quantity on the asset side.
+    /// @param liability Identifier for the liability side.
+    /// @param debt Quantity owed on the liability side.
+    /// @param action Primary operation hint from `Actions` that produced the position.
+    event Positioned(bytes32 indexed account, bytes32 asset, uint amount, bytes32 liability, uint debt, uint32 action);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/execution/Execution.sol

@@ -15,6 +15,7 @@ import {max16} from "../utils/Utils.sol";
 /// @dev `decoders` contains tagged input and state cursor lanes. Cursor operations
 /// select one logical lane by swapping it into the lower 128 bits.
 struct Execution {
+    bytes32 account;
     uint budget;
     uint decoders;
     uint writers;
@@ -195,6 +196,33 @@ library Executions {
         return exec.decoders.select(lane).absolute();
     }
 
+    /// @dev Return the complete validated calldata source for a decoder lane.
+    /// @dev Does not consume or depend on the lane's current position. A lane
+    /// absent because its descriptor is EMPTY returns an empty calldata slice.
+    /// @param exec Execution whose input or state source is requested.
+    /// @param lane Input or state decoder lane.
+    /// @return data Complete calldata region represented by the lane.
+    function raw(Execution memory exec, uint8 lane) private pure returns (bytes calldata data) {
+        if (!exec.decoders.contains(lane)) return msg.data[0:0];
+
+        uint cur = exec.decoders.select(lane);
+        (, uint offset, uint len) = cur.decode();
+        if (len > msg.data.length || offset > msg.data.length - len) revert Blocks.MalformedBlocks();
+        return msg.data[offset:offset + len];
+    }
+
+    /// @notice Return the complete validated command state without consuming it.
+    /// @dev Remains the complete original state after the state cursor advances.
+    function rawState(Execution memory exec) internal pure returns (bytes calldata) {
+        return raw(exec, Lanes.State);
+    }
+
+    /// @notice Return the complete validated endpoint input without consuming it.
+    /// @dev Remains the complete original input after the input cursor advances.
+    function rawInput(Execution memory exec) internal pure returns (bytes calldata) {
+        return raw(exec, Lanes.Input);
+    }
+
     /// @notice Return whether the next block on `lane` has `key` and an empty payload.
     /// @param exec Execution whose decoder is inspected without advancing.
     /// @param lane Decoder lane to inspect.
@@ -218,6 +246,20 @@ library Executions {
         exec.decoders = cur.seekAbs(end);
     }
 
+    /// @notice Validate and consume one block from a decoder lane, returning its complete encoding.
+    /// @param exec Execution whose selected decoder cursor is advanced past the block.
+    /// @param lane Execution decoder lane to select.
+    /// @param key Expected block key.
+    /// @return data Calldata view of the complete block, including its header.
+    function takeBlock(
+        Execution memory exec,
+        uint8 lane,
+        bytes4 key
+    ) internal pure returns (bytes calldata data) {
+        (uint abs, uint end) = consume(exec, lane, Specs.create(key, 0, 0, 0));
+        data = msg.data[abs - Sizes.Header:end];
+    }
+
     /// @notice Consume a matching empty block from an execution decoder lane when present.
     /// @param exec Execution whose selected decoder advances only for a matching empty block.
     /// @param lane Decoder lane to consume.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",

package/ports/Allowance.sol

@@ -2,35 +2,45 @@
 pragma solidity ^0.8.33;
 
 import {PortBase} from "./Base.sol";
-import {AllowanceHook} from "../commands/admin/Allowance.sol";
 import {Specs} from "../Codec.sol";
 import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title AllowancePort
-/// @notice Port that lets a trusted peer host input or refresh its own allowance.
-/// Each AMOUNT block in the input is scoped to the peer host and passed to the
-/// shared allowance hook as a host-scoped allowance. Restricted to trusted peers.
-abstract contract AllowancePort is PortBase, AllowanceHook {
+/// @notice Hook implemented by hosts that handle allowance requests from peers.
+abstract contract RequestAllowanceHook {
+    /// @notice Override to handle one allowance request from a peer host.
+    /// @dev The implementation is responsible for validating the request and
+    /// deciding what allowance, if any, to grant.
+    /// @param peer Peer host node ID requesting the allowance.
+    /// @param asset Asset identifier supplied by the peer.
+    /// @param amount Allowance amount requested in the asset's native units.
+    function requestAllowance(uint peer, bytes32 asset, uint amount) internal virtual;
+}
+
+/// @title RequestAllowancePort
+/// @notice Port that lets trusted peers request their own asset allowances.
+/// Each AMOUNT block is scoped to the caller and passed unchanged to
+/// `requestAllowance(peer, asset, amount)`.
+abstract contract RequestAllowancePort is PortBase, RequestAllowanceHook {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = port("portAllowance", Specs.Amount, Specs.Empty, 0);
+        (, descriptor) = port("portRequestAllowance", Specs.Amount, Specs.Empty, 0);
     }
 
-    /// @notice Execute the allowance port call.
-    /// @param data AMOUNT block stream requested by the trusted peer.
+    /// @notice Request asset allowances for the calling peer.
+    /// @param data AMOUNT block stream supplied by the trusted peer.
     /// @return Empty response bytes.
-    function portAllowance(bytes calldata data) external onlyPeer returns (bytes memory) {
+    function portRequestAllowance(bytes calldata data) external onlyPeer returns (bytes memory) {
         Execution memory exec = openInput(data, descriptor, 0);
         uint peer = caller();
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
-            allowance(peer, asset, amount);
+            requestAllowance(peer, asset, amount);
         }
-        
+
         return "";
     }
 }

package/ports/Assets.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortBase} from "./Base.sol";
+import {AllowAssetsHook} from "../commands/admin/AllowAssets.sol";
+import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
+import {Specs} from "../Codec.sol";
+import {Execution, Executions, Lanes} from "../execution/Execution.sol";
+
+using Executions for Execution;
+
+/// @title AllowAssetsPort
+/// @notice Port that permits a list of assets on behalf of a peer host.
+/// Each ASSET block in the input calls `allowAsset`. Restricted to trusted peers.
+abstract contract AllowAssetsPort is PortBase, AllowAssetsHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portAllowAssets", Specs.Asset, Specs.Empty, 0);
+    }
+
+    /// @notice Execute the allow-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portAllowAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+
+        while (exec.more()) {
+            bytes32 asset = exec.unpackAsset(Lanes.Input);
+            allowAsset(asset);
+        }
+
+        return "";
+    }
+}
+
+/// @title DenyAssetsPort
+/// @notice Port that blocks a list of assets on behalf of a peer host.
+/// Each ASSET block in the input calls `denyAsset`. Restricted to trusted peers.
+abstract contract DenyAssetsPort is PortBase, DenyAssetsHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portDenyAssets", Specs.Asset, Specs.Empty, 0);
+    }
+
+    /// @notice Execute the deny-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portDenyAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+
+        while (exec.more()) {
+            bytes32 asset = exec.unpackAsset(Lanes.Input);
+            denyAsset(asset);
+        }
+
+        return "";
+    }
+}
+
+/// @notice Hook implemented by hosts that fulfill asset requests from peers.
+abstract contract RequestAssetHook {
+    /// @notice Override to handle one asset request from a peer host.
+    /// @dev The implementation is responsible for validating `asset`, enforcing
+    /// requester policy, and sending the approved amount to the requester.
+    /// @param peer Peer host node ID for this request.
+    /// @param asset Asset identifier supplied by the peer.
+    /// @param amount Amount requested in the asset's native units.
+    function requestAsset(uint peer, bytes32 asset, uint amount) internal virtual;
+}
+
+/// @title RequestAssetPort
+/// @notice Port that lets trusted peers request assets from the receiving host.
+/// Each AMOUNT block is scoped to the caller and passed unchanged to
+/// `requestAsset(peer, asset, amount)`. The hook validates support and performs
+/// any accounting and transfer required by the host.
+abstract contract RequestAssetPort is PortBase, RequestAssetHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portRequestAsset", Specs.Amount, Specs.Empty, 0);
+    }
+
+    /// @notice Request assets for the calling peer.
+    /// @param data AMOUNT block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portRequestAsset(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+        uint peer = caller();
+
+        while (exec.more()) {
+            (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
+            requestAsset(peer, asset, amount);
+        }
+
+        return "";
+    }
+}

package/utils/Cursors.sol

@@ -65,9 +65,9 @@ library Cursors {
     /// @param tag Cursor identity tag.
     /// @return cur Packed cursor.
     function create(uint offset, uint len, uint items, uint8 flags, uint8 tag) internal pure returns (uint cur) {
-        cur |= max32(offset) << 32;
-        cur |= max32(len) << 64;
-        cur |= max16(items) << 96;
+        cur |= uint(max32(offset)) << 32;
+        cur |= uint(max32(len)) << 64;
+        cur |= uint(max16(items)) << 96;
         cur |= uint(flags) << 112;
         cur |= uint(tag) << 120;
     }

package/utils/Nodes.sol

@@ -198,7 +198,7 @@ library Nodes {
     /// @return node Command node ID embedding both the selector and address.
     function toCommand(string memory name, address target) internal view returns (uint node) {
         node = toLocalBase(Command) | uint(uint160(target));
-        node |= uint(uint32(toSelector(name, "(bytes32,bytes,bytes)"))) << 160;
+        node |= uint(uint32(toSelector(name, "(bytes)"))) << 160;
     }
 
     /// @notice Build a chain-local port ID for the given endpoint name and contract.

package/utils/Utils.sol

@@ -11,76 +11,76 @@ error NotDivisible();
 /// @dev Thrown when an ID claims to carry an address but the embedded address is zero.
 error ZeroAddress();
 
-/// @notice Assert that `value` fits in uint8 and return it unchanged.
-function max8(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint8 and return it as uint8.
+function max8(uint value) pure returns (uint8) {
     if (value > type(uint8).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint8(value);
 }
 
-/// @notice Assert that `value` fits in uint16 and return it unchanged.
-function max16(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint16 and return it as uint16.
+function max16(uint value) pure returns (uint16) {
     if (value > type(uint16).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint16(value);
 }
 
-/// @notice Assert that `value` fits in uint24 and return it unchanged.
-function max24(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint24 and return it as uint24.
+function max24(uint value) pure returns (uint24) {
     if (value > type(uint24).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint24(value);
 }
 
-/// @notice Assert that `value` fits in uint32 and return it unchanged.
-function max32(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint32 and return it as uint32.
+function max32(uint value) pure returns (uint32) {
     if (value > type(uint32).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint32(value);
 }
 
-/// @notice Assert that `value` fits in uint40 and return it unchanged.
-function max40(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint40 and return it as uint40.
+function max40(uint value) pure returns (uint40) {
     if (value > type(uint40).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint40(value);
 }
 
-/// @notice Assert that `value` fits in uint64 and return it unchanged.
-function max64(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint64 and return it as uint64.
+function max64(uint value) pure returns (uint64) {
     if (value > type(uint64).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint64(value);
 }
 
-/// @notice Assert that `value` fits in uint96 and return it unchanged.
-function max96(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint96 and return it as uint96.
+function max96(uint value) pure returns (uint96) {
     if (value > type(uint96).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint96(value);
 }
 
-/// @notice Assert that `value` fits in uint128 and return it unchanged.
-function max128(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint128 and return it as uint128.
+function max128(uint value) pure returns (uint128) {
     if (value > type(uint128).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint128(value);
 }
 
-/// @notice Assert that `value` fits in uint160 and return it unchanged.
-function max160(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint160 and return it as uint160.
+function max160(uint value) pure returns (uint160) {
     if (value > type(uint160).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint160(value);
 }
 
 // Packed fields
@@ -108,25 +108,25 @@ function clear64(uint value, uint shift) pure returns (uint) {
 /// @notice Replace the 8-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 8 bits.
 function replace8(uint value, uint shift, uint field) pure returns (uint) {
-    return clear8(value, shift) | (max8(field) << shift);
+    return clear8(value, shift) | (uint(max8(field)) << shift);
 }
 
 /// @notice Replace the 16-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 16 bits.
 function replace16(uint value, uint shift, uint field) pure returns (uint) {
-    return clear16(value, shift) | (max16(field) << shift);
+    return clear16(value, shift) | (uint(max16(field)) << shift);
 }
 
 /// @notice Replace the 32-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 32 bits.
 function replace32(uint value, uint shift, uint field) pure returns (uint) {
-    return clear32(value, shift) | (max32(field) << shift);
+    return clear32(value, shift) | (uint(max32(field)) << shift);
 }
 
 /// @notice Replace the 64-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 64 bits.
 function replace64(uint value, uint shift, uint field) pure returns (uint) {
-    return clear64(value, shift) | (max64(field) << shift);
+    return clear64(value, shift) | (uint(max64(field)) << shift);
 }
 
 /// @notice Assert that `n` is evenly divisible by `divisor`.

package/events/Commander.sol

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {EventEmitter} from "./Emitter.sol";
-
-/// @notice Emitted when a commander is announced for a chain/domain.
-abstract contract CommanderEvent is EventEmitter {
-    string private constant ABI = "event Commander(uint indexed host, uint chain, bytes32 native, bytes32 admin)";
-
-    /// @param host Commander host node ID for the chain.
-    /// @param chain Chain/domain node ID.
-    /// @param native Native asset ID for the chain.
-    /// @param admin Admin account for the commander host on the chain.
-    event Commander(uint indexed host, uint chain, bytes32 native, bytes32 admin);
-
-    constructor() {
-        emit EventAbi(ABI);
-    }
-}

package/ports/AllowAssets.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {PortBase} from "./Base.sol";
-import {AllowAssetsHook} from "../commands/admin/AllowAssets.sol";
-import {Specs} from "../Codec.sol";
-import {Execution, Executions, Lanes} from "../execution/Execution.sol";
-
-using Executions for Execution;
-
-/// @title AllowAssetsPort
-/// @notice Port that permits a list of assets on behalf of a peer host.
-/// Each ASSET block in the input calls `allowAsset`. Restricted to trusted peers.
-abstract contract AllowAssetsPort is PortBase, AllowAssetsHook {
-    uint private immutable descriptor;
-
-    constructor() {
-        (, descriptor) = port("portAllowAssets", Specs.Asset, Specs.Empty, 0);
-    }
-
-    /// @notice Execute the allow-assets peer call.
-    /// @param data ASSET block stream supplied by the trusted peer.
-    /// @return Empty response bytes.
-    function portAllowAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
-        Execution memory exec = openInput(data, descriptor, 0);
-
-        while (exec.more()) {
-            bytes32 asset = exec.unpackAsset(Lanes.Input);
-            allowAsset(asset);
-        }
-        
-        return "";
-    }
-}

package/ports/DenyAssets.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {PortBase} from "./Base.sol";
-import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
-import {Specs} from "../Codec.sol";
-import {Execution, Executions, Lanes} from "../execution/Execution.sol";
-
-using Executions for Execution;
-
-/// @title DenyAssetsPort
-/// @notice Port that blocks a list of assets on behalf of a peer host.
-/// Each ASSET block in the input calls `denyAsset`. Restricted to trusted peers.
-abstract contract DenyAssetsPort is PortBase, DenyAssetsHook {
-    uint private immutable descriptor;
-
-    constructor() {
-        (, descriptor) = port("portDenyAssets", Specs.Asset, Specs.Empty, 0);
-    }
-
-    /// @notice Execute the deny-assets peer call.
-    /// @param data ASSET block stream supplied by the trusted peer.
-    /// @return Empty response bytes.
-    function portDenyAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
-        Execution memory exec = openInput(data, descriptor, 0);
-
-        while (exec.more()) {
-            bytes32 asset = exec.unpackAsset(Lanes.Input);
-            denyAsset(asset);
-        }
-        
-        return "";
-    }
-}