@fastish/contracts 0.1.0

package/contracts/commands/Burn.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {BALANCES, SETUP} from "../utils/Channels.sol";
+import {Blocks, BlockRef} from "../Blocks.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "burn";
+
+abstract contract Burn is CommandBase {
+    uint internal immutable burnId = commandId(NAME);
+
+    constructor(string memory route) {
+        emit Command(host, NAME, route, burnId, BALANCES, SETUP);
+    }
+
+    function burn(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual returns (uint);
+
+    function burn(CommandContext calldata c) external payable onlyCommand(burnId, c.target) returns (bytes memory) {
+        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);
+            burn(c.account, asset, meta, amount);
+            i = ref.end;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/Create.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 = "create";
+
+abstract contract Create is CommandBase {
+    uint internal immutable createId = commandId(NAME);
+
+    constructor(string memory route) {
+        emit Command(host, NAME, route, createId, SETUP, SETUP);
+    }
+
+    function create(bytes32 account, DataRef memory rawRoute) internal virtual;
+
+    function create(CommandContext calldata c) external payable onlyCommand(createId, 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;
+            create(c.account, ref);
+            q = next;
+        }
+
+        return done(0, q);
+    }
+}

package/contracts/commands/CreditTo.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {BALANCES, SETUP} from "../utils/Channels.sol";
+import {BlockRef, RECIPIENT} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+string constant NAME = "creditBalanceToAccount";
+
+using Blocks for BlockRef;
+
+abstract contract CreditBalanceToAccount is CommandBase {
+    uint internal immutable creditBalanceToAccountId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, RECIPIENT, creditBalanceToAccountId, BALANCES, SETUP);
+    }
+
+    function creditAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function creditBalanceToAccount(
+        CommandContext calldata c
+    ) external payable onlyCommand(creditBalanceToAccountId, 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);
+            creditAccount(to, asset, meta, amount);
+            i = ref.end;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/DebitFrom.sol

@@ -0,0 +1,44 @@
+// 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 {AMOUNT, AMOUNT_KEY, BlockRef, Writer} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+import {Writers} from "../blocks/Writers.sol";
+
+string constant NAME = "debitAccountToBalance";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+abstract contract DebitAccountToBalance is CommandBase {
+    uint internal immutable debitAccountToBalanceId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, AMOUNT, debitAccountToBalanceId, SETUP, BALANCES);
+    }
+
+    function debitAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function debitAccountToBalance(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(request, q, AMOUNT_KEY);
+
+        while (q < end) {
+            BlockRef memory ref = Blocks.from(request, q);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount(request);
+            debitAccount(from, asset, meta, amount);
+            writer.appendBalance(asset, meta, amount);
+            q = ref.end;
+        }
+
+        return writer.done();
+    }
+
+    function debitAccountToBalance(
+        CommandContext calldata c
+    ) external payable onlyCommand(debitAccountToBalanceId, c.target) returns (bytes memory) {
+        return debitAccountToBalance(c.account, c.request);
+    }
+}

package/contracts/commands/Deposit.sol

@@ -0,0 +1,46 @@
+// 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 {AMOUNT, AMOUNT_KEY, BlockRef, Writer} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+import {Writers} from "../blocks/Writers.sol";
+
+string constant NAME = "deposit";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+// @dev Use `deposit` for externally sourced assets; use `debitAccountToBalance` for internal balance deductions.
+abstract contract Deposit is CommandBase {
+    uint internal immutable depositId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, AMOUNT, depositId, SETUP, BALANCES);
+    }
+
+    function deposit(
+        bytes32 account,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount
+    ) internal virtual;
+
+    function deposit(
+        CommandContext calldata c
+    ) external payable onlyCommand(depositId, c.target) returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint next) = Writers.allocBalancesFrom(c.request, q, AMOUNT_KEY);
+
+        while (q < next) {
+            BlockRef memory ref = Blocks.from(c.request, q);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount(c.request);
+            deposit(c.account, asset, meta, amount);
+            writer.appendBalance(asset, meta, amount);
+            q = ref.end;
+        }
+
+        return writer.done();
+    }
+}

package/contracts/commands/Fund.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, CUSTODIES} from "../utils/Channels.sol";
+import {BALANCE_KEY, Blocks, BlockRef, NODE, Writers, Writer} from "../Blocks.sol";
+using Blocks for BlockRef;
+using Writers for Writer;
+
+string constant NAME = "fund";
+
+// @dev Converts BALANCE state into CUSTODY state for a destination host.
+abstract contract Fund is CommandBase {
+    uint internal immutable fundId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, NODE, fundId, BALANCES, CUSTODIES);
+    }
+
+    function fund(uint host, bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function fund(CommandContext calldata c) external payable onlyCommand(fundId, c.target) returns (bytes memory) {
+        uint h = Blocks.resolveNode(c.request, 0, c.request.length, 0);
+        uint i = 0;
+        (Writer memory writer, uint end) = Writers.allocCustodiesFrom(c.state, i, BALANCE_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(c.state, i);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackBalance(c.state);
+            fund(h, c.account, asset, meta, amount);
+            writer.appendCustody(h, asset, meta, amount);
+            i = ref.end;
+        }
+
+        return writer.done();
+    }
+}

package/contracts/commands/Liquidate.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 LFBTB = "liquidateFromBalanceToBalances";
+string constant LFCTB = "liquidateFromCustodyToBalances";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract LiquidateFromBalanceToBalances is CommandBase {
+    uint internal immutable liquidateFromBalanceToBalancesId = commandId(LFBTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, LFBTB, maybeRoute, liquidateFromBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev `balance` is the offered liquidation repayment amount and may leave a returned remainder.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function liquidateFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function liquidateFromBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(liquidateFromBalanceToBalancesId, 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);
+            liquidateFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract LiquidateFromCustodyToBalances is CommandBase {
+    uint internal immutable liquidateFromCustodyToBalancesId = commandId(LFCTB);
+    uint private immutable outScale;
+    bool private immutable useRoute;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        useRoute = bytes(maybeRoute).length > 0;
+        emit Command(host, LFCTB, maybeRoute, liquidateFromCustodyToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    // @dev `custody` is the offered liquidation repayment amount and may leave a returned remainder.
+    // `rawRoute` is zero-initialized and should be ignored when `maybeRoute` is empty.
+    function liquidateFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function liquidateFromCustodyToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(liquidateFromCustodyToBalancesId, 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);
+            liquidateFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Liquidity.sol

@@ -0,0 +1,171 @@
+// 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, MINIMUM, DataPairRef} from "../blocks/Schema.sol";
+import {BlockRef, Blocks, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+import {routeSchema1, routeSchema2} from "../utils/Utils.sol";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+string constant ALFCTB = "addLiquidityFromCustodiesToBalances";
+string constant ALFBTB = "addLiquidityFromBalancesToBalances";
+string constant RLFCTB = "removeLiquidityFromCustodyToBalances";
+string constant RLFBTB = "removeLiquidityFromBalanceToBalances";
+
+abstract contract AddLiquidityFromCustodiesToBalances is CommandBase {
+    uint internal immutable addLiquidityFromCustodiesToBalancesId = commandId(ALFCTB);
+    uint private immutable outScale;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        string memory schema = routeSchema1(maybeRoute, MINIMUM);
+        emit Command(host, ALFCTB, schema, addLiquidityFromCustodiesToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested minimum liquidity output from rawRoute.innerMinimum()
+    // and may append up to three balances per custody pair: two refunds plus the liquidity receipt.
+    function addLiquidityFromCustodiesToBalances(
+        bytes32 account,
+        DataPairRef memory rawCustodies,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function addLiquidityFromCustodiesToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(addLiquidityFromCustodiesToBalancesId, 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);
+            DataPairRef memory custodies;
+            (custodies, i) = Data.twoFrom(c.state, i);
+            addLiquidityFromCustodiesToBalances(c.account, custodies, route, writer);
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract RemoveLiquidityFromCustodyToBalances is CommandBase {
+    uint internal immutable removeLiquidityFromCustodyToBalancesId = commandId(RLFCTB);
+    uint private immutable outScale;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        string memory schema = routeSchema2(maybeRoute, MINIMUM, MINIMUM);
+        emit Command(host, RLFCTB, schema, removeLiquidityFromCustodyToBalancesId, CUSTODIES, BALANCES);
+    }
+
+    // @dev implementation extracts requested minimum outputs from rawRoute and
+    // may append up to two balances per custody input when removing liquidity.
+    function removeLiquidityFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function removeLiquidityFromCustodyToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(removeLiquidityFromCustodyToBalancesId, 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);
+            removeLiquidityFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract AddLiquidityFromBalancesToBalances is CommandBase {
+    uint internal immutable addLiquidityFromBalancesToBalancesId = commandId(ALFBTB);
+    uint private immutable outScale;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        string memory schema = routeSchema1(maybeRoute, MINIMUM);
+        emit Command(host, ALFBTB, schema, addLiquidityFromBalancesToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested minimum liquidity output from rawRoute.innerMinimum()
+    // and may append up to three balances per balance pair: two refunds plus the liquidity receipt.
+    function addLiquidityFromBalancesToBalances(
+        bytes32 account,
+        DataPairRef memory rawBalances,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function addLiquidityFromBalancesToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(addLiquidityFromBalancesToBalancesId, 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);
+            DataPairRef memory balances;
+            (balances, i) = Data.twoFrom(c.state, i);
+            addLiquidityFromBalancesToBalances(c.account, balances, route, writer);
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract RemoveLiquidityFromBalanceToBalances is CommandBase {
+    uint internal immutable removeLiquidityFromBalanceToBalancesId = commandId(RLFBTB);
+    uint private immutable outScale;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        string memory schema = routeSchema2(maybeRoute, MINIMUM, MINIMUM);
+        emit Command(host, RLFBTB, schema, removeLiquidityFromBalanceToBalancesId, BALANCES, BALANCES);
+    }
+
+    // @dev implementation extracts requested minimum outputs from rawRoute and
+    // may append up to two balances per balance input when removing liquidity.
+    function removeLiquidityFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function removeLiquidityFromBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(removeLiquidityFromBalanceToBalancesId, 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);
+            removeLiquidityFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Mint.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {BALANCES, SETUP} from "../utils/Channels.sol";
+import {ROUTE_KEY} from "../Schema.sol";
+import {Data, DataRef, Writers, Writer} from "../Blocks.sol";
+using Writers for Writer;
+
+string constant NAME = "mintToBalances";
+
+abstract contract MintToBalances is CommandBase {
+    uint internal immutable mintToBalancesId = commandId(NAME);
+    uint private immutable outScale;
+
+    constructor(string memory route, uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, NAME, route, mintToBalancesId, SETUP, BALANCES);
+    }
+
+    function mintToBalances(
+        bytes32 account,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function mintToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(mintToBalancesId, c.target) returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.request, q, ROUTE_KEY, outScale);
+
+        while (q < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            mintToBalances(c.account, route, writer);
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Pipe.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "./Base.sol";
+import {BlockRef, STEP, STEP_KEY} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+import {isAdminAccount, InvalidAccount} from "../utils/Accounts.sol";
+import {msgValue, useValue, ValueBudget} from "../utils/Value.sol";
+
+using Blocks for BlockRef;
+
+string constant NAME = "pipe";
+
+abstract contract Pipe is CommandBase {
+    uint internal immutable pipeId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, STEP, pipeId, 0, 0);
+    }
+
+    function dispatchStep(
+        uint target,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata request,
+        uint value
+    ) internal virtual returns (bytes memory);
+
+    function pipe(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata steps,
+        ValueBudget memory budget
+    ) internal returns (bytes memory) {
+        uint i = 0;
+        while (i < steps.length) {
+            BlockRef memory ref = Blocks.from(steps, i);
+            if (ref.key != STEP_KEY) break;
+            (uint target, uint value, bytes calldata request) = ref.unpackStep(steps);
+            uint spend = useValue(value, budget);
+            state = dispatchStep(target, account, state, request, spend);
+            i = ref.end;
+        }
+
+        return done(state, 0, i);
+    }
+
+    // Any unused value will not be credited back to the account using this path.
+    function pipe(CommandContext calldata c) external payable onlyCommand(pipeId, c.target) returns (bytes memory) {
+        if (isAdminAccount(c.account)) revert InvalidAccount();
+        ValueBudget memory budget = msgValue();
+        return pipe(c.account, c.state, c.request, budget);
+    }
+}

package/contracts/commands/Provision.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase} from "./Base.sol";
+import {CUSTODIES, SETUP} from "../utils/Channels.sol";
+import {HostAmount, AMOUNT, AMOUNT_KEY, NODE} from "../blocks/Schema.sol";
+import {Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+using Blocks for BlockRef;
+using Writers for Writer;
+
+string constant NAME = "provision";
+string constant REQUEST = string.concat(AMOUNT, ">", NODE);
+
+abstract contract Provision is CommandBase {
+    uint internal immutable provisionId = commandId(NAME);
+    uint private immutable outScale;
+
+    constructor(uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, NAME, REQUEST, provisionId, SETUP, CUSTODIES);
+    }
+
+    function provision(
+        bytes32 account,
+        uint host,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount,
+        Writer memory out
+    ) internal virtual;
+
+    function provision(
+        CommandContext calldata c
+    ) external payable onlyCommand(provisionId, c.target) returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledCustodiesFrom(c.request, q, AMOUNT_KEY, outScale);
+
+        while (q < end) {
+            BlockRef memory ref = Blocks.from(c.request, q);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount(c.request);
+            uint h = ref.innerNode(c.request);
+            provision(c.account, h, asset, meta, amount, writer);
+            q = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Reclaim.sol

@@ -0,0 +1,46 @@
+// 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 {AssetAmount, AMOUNT, ROUTE_KEY, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+import {routeSchema1} from "../utils/Utils.sol";
+
+string constant NAME = "reclaimToBalances";
+
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract ReclaimToBalances is CommandBase {
+    uint internal immutable reclaimToBalancesId = commandId(NAME);
+    uint private immutable outScale;
+
+    constructor(string memory maybeRoute, uint scaledRatio) {
+        outScale = scaledRatio;
+        string memory schema = routeSchema1(maybeRoute, AMOUNT);
+        emit Command(host, NAME, schema, reclaimToBalancesId, SETUP, BALANCES);
+    }
+
+    function reclaimToBalances(
+        bytes32 account,
+        AssetAmount memory amount,
+        DataRef memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function reclaimToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(reclaimToBalancesId, c.target) returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocScaledBalancesFrom(c.request, q, ROUTE_KEY, outScale);
+
+        while (q < end) {
+            DataRef memory route;
+            (route, q) = Data.routeFrom(c.request, q);
+            AssetAmount memory value = route.innerAmountValue();
+            reclaimToBalances(c.account, value, route, writer);
+        }
+
+        return writer.finish();
+    }
+}