@fastish/contracts 0.1.0

package/contracts/commands/Redeem.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {BALANCES, CUSTODIES} from "../utils/Channels.sol";
+import {AssetAmount, HostAmount, BALANCE_KEY, CUSTODY_KEY, Data, DataRef, Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+string constant RDBTB = "redeemFromBalanceToBalances";
+string constant RDCTB = "redeemFromCustodyToBalances";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract RedeemFromBalanceToBalances is CommandBase {
+    uint internal immutable redeemFromBalanceToBalancesId = commandId(RDBTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, RDBTB, maybeRoute, redeemFromBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev `balance` is the redeemable claim/share/position amount offered for redemption.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function redeemFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function redeemFromBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(redeemFromBalanceToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, BALANCE_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            if (useRoute) (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue(c.state);
+            redeemFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract RedeemFromCustodyToBalances is CommandBase {
+    uint internal immutable redeemFromCustodyToBalancesId = commandId(RDCTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, RDCTB, maybeRoute, redeemFromCustodyToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    // @dev `custody` is the redeemable claim/share/position amount offered for redemption.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function redeemFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function redeemFromCustodyToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(redeemFromCustodyToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, CUSTODY_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            if (useRoute) (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue(c.state);
+            redeemFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Remove.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {SETUP} from "../utils/Channels.sol";
+import {Data, DataRef, ROUTE_KEY} from "../Blocks.sol";
+using Data for DataRef;
+
+string constant NAME = "remove";
+
+abstract contract Remove is CommandBase {
+    uint internal immutable removeId = commandId(NAME);
+
+    constructor(string memory route) {
+        emit Command(host, NAME, route, removeId, SETUP, SETUP);
+    }
+
+    function remove(bytes32 account, DataRef memory rawRoute) internal virtual;
+
+    function remove(CommandContext calldata c) external payable onlyCommand(removeId, c.target) returns (bytes memory) {
+        uint q = 0;
+        while (q < c.request.length) {
+            (DataRef memory ref, uint next) = Data.from(c.request, q);
+            if (ref.key != ROUTE_KEY) break;
+            remove(c.account, ref);
+            q = next;
+        }
+
+        return done(0, q);
+    }
+}

package/contracts/commands/Repay.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {BALANCES, CUSTODIES} from "../utils/Channels.sol";
+import {AssetAmount, HostAmount, BALANCE_KEY, CUSTODY_KEY, ROUTE_EMPTY, Data, DataRef, Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+string constant RFBTB = "repayFromBalanceToBalances";
+string constant RFCTB = "repayFromCustodyToBalances";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract RepayFromBalanceToBalances is CommandBase {
+    uint internal immutable repayFromBalanceToBalancesId = commandId(RFBTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, RFBTB, maybeRoute, repayFromBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev `balance` is the offered repayment amount and may leave a returned remainder.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function repayFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function repayFromBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(repayFromBalanceToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, BALANCE_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            if (useRoute) (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue(c.state);
+            repayFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract RepayFromCustodyToBalances is CommandBase {
+    uint internal immutable repayFromCustodyToBalancesId = commandId(RFCTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, RFCTB, maybeRoute, repayFromCustodyToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    // @dev `custody` is the offered repayment amount and may leave a returned remainder.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function repayFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function repayFromCustodyToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(repayFromCustodyToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, CUSTODY_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            if (useRoute) (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue(c.state);
+            repayFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Settle.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {TRANSACTIONS, SETUP} from "../utils/Channels.sol";
+import {BlockRef, TX_KEY, Tx} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "settle";
+
+abstract contract Settle is CommandBase {
+    uint internal immutable settleId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, "", settleId, TRANSACTIONS, SETUP);
+    }
+
+    function settle(Tx memory value) internal virtual;
+
+    function settle(CommandContext calldata c) external payable onlyCommand(settleId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.state.length) {
+            BlockRef memory ref = Blocks.from(c.state, i);
+            if (ref.key != TX_KEY) break;
+            Tx memory value = ref.toTxValue(c.state);
+            settle(value);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/Stake.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {SETUP, BALANCES, CUSTODIES} from "../utils/Channels.sol";
+import {AssetAmount, HostAmount, BALANCE_KEY, CUSTODY_KEY, Blocks, BlockRef, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+
+string constant SBTB = "stakeBalanceToBalances";
+string constant SCTB = "stakeCustodyToBalances";
+string constant SCTP = "stakeCustodyToPosition";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract StakeBalanceToBalances is CommandBase {
+    uint internal immutable stakeBalanceToBalancesId = commandId(SBTB);
+    uint private immutable outScale;
+
+    constructor(string memory route, uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, SBTB, route, stakeBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    function stakeBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function stakeBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(stakeBalanceToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, BALANCE_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue(c.state);
+            stakeBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract StakeCustodyToBalances is CommandBase {
+    uint internal immutable stakeCustodyToBalancesId = commandId(SCTB);
+    uint private immutable outScale;
+
+    constructor(string memory route, uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, SCTB, route, stakeCustodyToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    function stakeCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function stakeCustodyToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(stakeCustodyToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, CUSTODY_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue(c.state);
+            stakeCustodyToBalances(c.account, custody, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract StakeCustodyToPosition is CommandBase {
+    uint internal immutable stakeCustodyToPositionId = commandId(SCTP);
+
+    constructor(string memory route) {
+        emit Command(host, SCTP, route, stakeCustodyToPositionId, CUSTODIES, SETUP);
+    }
+
+    function stakeCustodyToPosition(bytes32 account, HostAmount memory custody, DataRef memory rawRoute) internal virtual;
+
+    function stakeCustodyToPosition(
+        CommandContext calldata c
+    ) external payable onlyCommand(stakeCustodyToPositionId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        while (i < c.state.length) {
+            BlockRef memory ref = Blocks.from(c.state, i);
+            if (!ref.isCustody()) break;
+            HostAmount memory custody = ref.toCustodyValue(c.state);
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            stakeCustodyToPosition(c.account, custody, route);
+            i = ref.end;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/Supply.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {CUSTODIES, SETUP} from "../utils/Channels.sol";
+import {Blocks, BlockRef, HostAmount} from "../Blocks.sol";
+string constant NAME = "supply";
+
+using Blocks for BlockRef;
+
+abstract contract Supply is CommandBase {
+    uint internal immutable supplyId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, "", supplyId, CUSTODIES, SETUP);
+    }
+
+    function supply(bytes32 account, HostAmount memory value) internal virtual;
+
+    function supply(CommandContext calldata c) external payable onlyCommand(supplyId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.state.length) {
+            BlockRef memory ref = Blocks.from(c.state, i);
+            if (!ref.isCustody()) break;
+            HostAmount memory value = ref.toCustodyValue(c.state);
+            supply(c.account, value);
+            i = ref.end;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/Swap.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {BALANCES, CUSTODIES} from "../utils/Channels.sol";
+import {AssetAmount, HostAmount, BALANCE_KEY, CUSTODY_KEY, ROUTE_KEY, MINIMUM} from "../blocks/Schema.sol";
+import {Blocks, BlockRef, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+import {routeSchema1} from "../utils/Utils.sol";
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+string constant SEBTB = "swapExactBalanceToBalance";
+string constant SECTB = "swapExactCustodyToBalance";
+
+abstract contract SwapExactBalanceToBalance is CommandBase {
+    uint internal immutable swapExactBalanceToBalanceId = commandId(SEBTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = routeSchema1(maybeRoute, MINIMUM);
+        emit Command(host, SEBTB, schema, swapExactBalanceToBalanceId, BALANCES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested minimum from rawRoute.innerMinimum()
+    function swapExactBalanceToBalance(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute
+    ) internal virtual returns (AssetAmount memory out);
+
+    function swapExactBalanceToBalance(
+        CommandContext calldata c
+    ) external payable onlyCommand(swapExactBalanceToBalanceId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(c.state, i, BALANCE_KEY);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue(c.state);
+            AssetAmount memory out = swapExactBalanceToBalance(c.account, balance, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract SwapExactCustodyToBalance is CommandBase {
+    uint internal immutable swapExactCustodyToBalanceId = commandId(SECTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = routeSchema1(maybeRoute, MINIMUM);
+        emit Command(host, SECTB, schema, swapExactCustodyToBalanceId, CUSTODIES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested minimum from rawRoute.innerMinimum()
+    function swapExactCustodyToBalance(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute
+    ) internal virtual returns (AssetAmount memory out);
+
+    function swapExactCustodyToBalance(
+        CommandContext calldata c
+    ) external payable onlyCommand(swapExactCustodyToBalanceId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(c.state, i, CUSTODY_KEY);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue(c.state);
+            AssetAmount memory out = swapExactCustodyToBalance(c.account, custody, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Transfer.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {SETUP} from "../utils/Channels.sol";
+import {AMOUNT, RECIPIENT, AMOUNT_KEY, BlockRef} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "transfer";
+string constant REQUEST = string.concat(AMOUNT, ">", RECIPIENT);
+
+abstract contract Transfer is CommandBase {
+    uint internal immutable transferId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, REQUEST, transferId, SETUP, SETUP);
+    }
+
+    function transfer(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function transfer(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            BlockRef memory ref = Blocks.from(request, q);
+            if (ref.key != AMOUNT_KEY) break;
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount(request);
+            bytes32 to = ref.innerRecipientAt(request, ref.bound);
+            transfer(from, to, asset, meta, amount);
+            q = ref.end;
+        }
+
+        return done(0, q);
+    }
+
+    function transfer(
+        CommandContext calldata c
+    ) external payable onlyCommand(transferId, c.target) returns (bytes memory) {
+        return transfer(c.account, c.request);
+    }
+}

package/contracts/commands/Unstake.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {BALANCES} from "../utils/Channels.sol";
+import {AssetAmount, BALANCE_KEY, Blocks, BlockRef, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+
+string constant UBTB = "unstakeBalanceToBalances";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract UnstakeBalanceToBalances is CommandBase {
+    uint internal immutable unstakeBalanceToBalancesId = commandId(UBTB);
+    uint private immutable outScale;
+
+    constructor(string memory route, uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, UBTB, route, unstakeBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev `balance` is the input stake/share/LP-style position being redeemed.
+    function unstakeBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function unstakeBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(unstakeBalanceToBalancesId, c.target) returns (bytes memory) {
+        uint i = 0;
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.state, i, BALANCE_KEY, outScale);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            BlockRef memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue(c.state);
+            unstakeBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Withdraw.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {BALANCES, SETUP} from "../utils/Channels.sol";
+import {BlockRef, RECIPIENT} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "withdraw";
+
+// @dev Use `withdraw` for externally delivered assets; use `creditBalanceToAccount` for internal balance credits.
+abstract contract Withdraw is CommandBase {
+    uint internal immutable withdrawId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, RECIPIENT, withdrawId, BALANCES, SETUP);
+    }
+
+    function withdraw(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function withdraw(
+        CommandContext calldata c
+    ) external payable onlyCommand(withdrawId, c.target) returns (bytes memory) {
+        bytes32 to = Blocks.resolveRecipient(c.request, 0, c.request.length, c.account);
+        uint i = 0;
+        while (i < c.state.length) {
+            BlockRef memory ref = Blocks.from(c.state, i);
+            if (!ref.isBalance()) break;
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackBalance(c.state);
+            withdraw(to, asset, meta, amount);
+            i = ref.end;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Allocate.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {ALLOCATION, ALLOCATION_KEY, BlockRef, HostAmount} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+import {ensureAssetRef} from "../../utils/Assets.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "allocate";
+
+abstract contract Allocate is CommandBase {
+    uint internal immutable allocateId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, ALLOCATION, allocateId, SETUP, SETUP);
+    }
+
+    function allocate(uint host, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function allocate(CommandContext calldata c) external payable onlyAdmin(c.account) onlyCommand(allocateId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != ALLOCATION_KEY) break;
+            HostAmount memory v = ref.toAllocationValue(c.request);
+            allocate(v.host, v.asset, v.meta, v.amount);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/AllowAssets.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {ASSET, ASSET_KEY, BlockRef} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "allowAssets";
+
+abstract contract AllowAssets is CommandBase {
+    uint internal immutable allowAssetsId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, ASSET, allowAssetsId, SETUP, SETUP);
+    }
+
+    function allowAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
+
+    function allowAssets(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(allowAssetsId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != ASSET_KEY) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset(c.request);
+            allowAsset(asset, meta);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}