@fastish/contracts 0.1.0

package/contracts/blocks/Schema.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+// Block stream:
+// - encoding is [bytes4 key][bytes4 selfLen][bytes4 totalLen][self payload][child blocks...]
+// - `selfLen` covers only the block payload
+// - `totalLen` covers payload plus child blocks
+// - payload layout is block-specific
+//
+// Extensible payloads:
+// - self payload may be [head][dynamic tail]
+// - head layout is implied by the block key
+// - one dynamic field may consume the rest of self payload without its own length prefix
+// - child blocks, if any, are encoded as a normal nested block stream
+//
+// Schema DSL:
+// - `;` separates top-level sibling blocks
+// - `>` attaches child blocks to the preceding parent
+// - repeated `>` adds more children to the same parent, not to the previous child
+// - `->` separates request and response shapes, appears at most once, and is omitted when no output is modeled
+// - top-level blocks of the same type should be grouped together
+// - primary / driving blocks should appear before auxiliary blocks
+// - `route(<fields...>)` is a reserved extensible schema form whose key is always `ROUTE_KEY`
+// - canonical blocks are `amount(...)` for request amounts, `balance(...)` for state balances,
+//   `minimum(...)` for result floors, `maximum(...)` for spend ceilings, and `quantity(...)`
+//   for plain scalar amounts
+// - `auth(uint cid, uint deadline, bytes proof)` is a proof-separator child and must be emitted last
+//
+// Signed blocks:
+// - a signed top-level block ends with one trailing AUTH child
+// - only the final AUTH is treated specially; earlier AUTH blocks remain ordinary signed child bytes
+// - the signed slice runs from the parent block start through the AUTH head, excluding only AUTH proof bytes
+// - `cid` binds the signature to one command; `deadline` acts as expiry and nonce
+// - current helpers assume proof layout `[bytes20 signer][bytes65 sig]`
+
+string constant AMOUNT = "amount(bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant AMOUNT_KEY = bytes4(keccak256("amount(bytes32 asset, bytes32 meta, uint amount)"));
+string constant BALANCE = "balance(bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant BALANCE_KEY = bytes4(keccak256("balance(bytes32 asset, bytes32 meta, uint amount)"));
+string constant CUSTODY = "custody(uint host, bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant CUSTODY_KEY = bytes4(keccak256("custody(uint host, bytes32 asset, bytes32 meta, uint amount)"));
+string constant MINIMUM = "minimum(bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant MINIMUM_KEY = bytes4(keccak256("minimum(bytes32 asset, bytes32 meta, uint amount)"));
+string constant MAXIMUM = "maximum(bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant MAXIMUM_KEY = bytes4(keccak256("maximum(bytes32 asset, bytes32 meta, uint amount)"));
+string constant ROUTE = "route(bytes data)";
+string constant ROUTE_EMPTY = "route()";
+bytes4 constant ROUTE_KEY = bytes4(keccak256("route(bytes data)"));
+string constant QUANTITY = "quantity(uint amount)";
+bytes4 constant QUANTITY_KEY = bytes4(keccak256("quantity(uint amount)"));
+string constant RATE = "rate(uint value)";
+bytes4 constant RATE_KEY = bytes4(keccak256("rate(uint value)"));
+string constant PARTY = "party(bytes32 account)";
+bytes4 constant PARTY_KEY = bytes4(keccak256("party(bytes32 account)"));
+string constant RECIPIENT = "recipient(bytes32 account)";
+bytes4 constant RECIPIENT_KEY = bytes4(keccak256("recipient(bytes32 account)"));
+string constant TX = "tx(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant TX_KEY = bytes4(keccak256("tx(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)"));
+string constant STEP = "step(uint target, uint value, bytes request)";
+bytes4 constant STEP_KEY = bytes4(keccak256("step(uint target, uint value, bytes request)"));
+string constant AUTH = "auth(uint cid, uint deadline, bytes proof)";
+bytes4 constant AUTH_KEY = bytes4(keccak256("auth(uint cid, uint deadline, bytes proof)"));
+string constant ASSET = "asset(bytes32 asset, bytes32 meta)";
+bytes4 constant ASSET_KEY = bytes4(keccak256("asset(bytes32 asset, bytes32 meta)"));
+string constant NODE = "node(uint id)";
+bytes4 constant NODE_KEY = bytes4(keccak256("node(uint id)"));
+string constant LISTING = "listing(uint host, bytes32 asset, bytes32 meta)";
+bytes4 constant LISTING_KEY = bytes4(keccak256("listing(uint host, bytes32 asset, bytes32 meta)"));
+string constant FUNDING = "funding(uint host, uint amount)";
+bytes4 constant FUNDING_KEY = bytes4(keccak256("funding(uint host, uint amount)"));
+string constant ALLOCATION = "allocation(uint host, bytes32 asset, bytes32 meta, uint amount)";
+bytes4 constant ALLOCATION_KEY = bytes4(keccak256("allocation(uint host, bytes32 asset, bytes32 meta, uint amount)"));
+string constant BOUNTY = "bounty(uint amount, bytes32 relayer)";
+bytes4 constant BOUNTY_KEY = bytes4(keccak256("bounty(uint amount, bytes32 relayer)"));
+
+uint constant AUTH_PROOF_LEN = 85;
+uint constant AUTH_TOTAL_LEN = 161;
+
+struct AssetAmount {
+    bytes32 asset;
+    bytes32 meta;
+    uint amount;
+}
+
+struct HostAmount {
+    uint host;
+    bytes32 asset;
+    bytes32 meta;
+    uint amount;
+}
+
+struct UserAmount {
+    bytes32 account;
+    bytes32 asset;
+    bytes32 meta;
+    uint amount;
+}
+
+struct Listing {
+    uint host;
+    bytes32 asset;
+    bytes32 meta;
+}
+
+struct Tx {
+    bytes32 from;
+    bytes32 to;
+    bytes32 asset;
+    bytes32 meta;
+    uint amount;
+}
+
+struct BlockRef {
+    bytes4 key;
+    uint i;
+    uint bound;
+    uint end;
+}
+
+struct BlockPairRef {
+    BlockRef a;
+    BlockRef b;
+}
+
+struct DataRef {
+    bytes4 key;
+    uint i;
+    uint bound;
+    uint end;
+}
+
+struct DataPairRef {
+    DataRef a;
+    DataRef b;
+}
+
+struct MemRef {
+    bytes4 key;
+    uint i;
+    uint bound;
+    uint end;
+}
+
+struct Writer {
+    uint i;
+    uint end;
+    bytes dst;
+}

package/contracts/blocks/Writers.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Blocks} from "./Readers.sol";
+import {MalformedBlocks} from "./Errors.sol";
+import {AssetAmount, BALANCE_KEY, CUSTODY_KEY, HostAmount, TX_KEY, Tx, Writer} from "./Schema.sol";
+
+error WriterOverflow();
+error IncompleteWriter();
+error EmptyRequest();
+
+uint constant ALLOC_SCALE = 10_000;
+uint constant BALANCE_BLOCK_LEN = 108;
+uint constant CUSTODY_BLOCK_LEN = 140;
+uint constant TX_BLOCK_LEN = 172;
+
+library Writers {
+    // Encodes a 12-byte block header (4-byte key + 4-byte selfLen + 4-byte totalLen) into a uint so assembly can
+    // write the full header in one mstore while the payload starts at offset + 12.
+    function toBlockHeader(bytes4 key, uint selfLen, uint totalLen) internal pure returns (uint) {
+        if (selfLen > type(uint32).max || totalLen > type(uint32).max || selfLen > totalLen) revert MalformedBlocks();
+        return (uint(uint32(key)) << 224) | (uint(uint32(selfLen)) << 192) | (uint(uint32(totalLen)) << 160);
+    }
+
+    function alloc(uint len) internal pure returns (Writer memory writer) {
+        writer = Writer({i: 0, end: len, dst: new bytes(len)});
+    }
+
+    function append(Writer memory writer, bytes memory data) internal pure {
+        uint next = writer.i + data.length;
+        if (next > writer.dst.length) revert WriterOverflow();
+        assembly ("memory-safe") {
+            mcopy(add(add(mload(add(writer, 0x40)), 0x20), mload(writer)), add(data, 0x20), mload(data))
+        }
+        writer.i = next;
+    }
+
+    function allocBalancesFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, ALLOC_SCALE, BALANCE_BLOCK_LEN);
+    }
+
+    function allocPairedBalancesFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, ALLOC_SCALE * 2, BALANCE_BLOCK_LEN);
+    }
+
+    function allocScaledBalancesFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source,
+        uint scaledRatio
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, scaledRatio, BALANCE_BLOCK_LEN);
+    }
+
+    function allocTxsFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, ALLOC_SCALE, TX_BLOCK_LEN);
+    }
+
+    function allocCustodiesFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, ALLOC_SCALE, CUSTODY_BLOCK_LEN);
+    }
+
+    function allocScaledCustodiesFrom(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source,
+        uint scaledRatio
+    ) internal pure returns (Writer memory writer, uint next) {
+        return allocFromScaledCount(blocks, i, source, scaledRatio, CUSTODY_BLOCK_LEN);
+    }
+
+    function allocFromScaledCount(
+        bytes calldata blocks,
+        uint i,
+        bytes4 source,
+        uint scaledRatio,
+        uint blockLen
+    ) internal pure returns (Writer memory writer, uint next) {
+        uint count;
+        (count, next) = Blocks.count(blocks, i, source);
+        if (count == 0) revert EmptyRequest();
+        uint scaledCount = count * scaledRatio;
+        if (scaledCount % ALLOC_SCALE != 0) revert MalformedBlocks();
+        uint len = (scaledCount / ALLOC_SCALE) * blockLen;
+        writer = Writer({i: 0, end: len, dst: new bytes(len)});
+    }
+
+    function writeBalanceBlock(bytes memory dst, uint i, AssetAmount memory value) internal pure returns (uint next) {
+        next = i + BALANCE_BLOCK_LEN;
+        if (next > dst.length) revert WriterOverflow();
+        uint header = toBlockHeader(BALANCE_KEY, 96, 96);
+        assembly ("memory-safe") {
+            let p := add(add(dst, 0x20), i)
+            mstore(p, header)
+            mstore(add(p, 0x0c), mload(value))
+            mstore(add(p, 0x2c), mload(add(value, 0x20)))
+            mstore(add(p, 0x4c), mload(add(value, 0x40)))
+        }
+    }
+
+    function appendBalance(Writer memory writer, bytes32 asset, bytes32 meta, uint amount) internal pure {
+        appendBalance(writer, AssetAmount(asset, meta, amount));
+    }
+
+    function appendBalance(Writer memory writer, AssetAmount memory value) internal pure {
+        writer.i = writeBalanceBlock(writer.dst, writer.i, value);
+    }
+
+    function appendNonZeroBalance(Writer memory writer, bytes32 asset, bytes32 meta, uint amount) internal pure {
+        if (amount > 0) appendBalance(writer, asset, meta, amount);
+    }
+
+    function appendNonZeroBalance(Writer memory writer, AssetAmount memory value) internal pure {
+        if (value.amount > 0) appendBalance(writer, value);
+    }
+
+    function writeCustodyBlock(bytes memory dst, uint i, HostAmount memory value) internal pure returns (uint next) {
+        next = i + CUSTODY_BLOCK_LEN;
+        if (next > dst.length) revert WriterOverflow();
+        uint header = toBlockHeader(CUSTODY_KEY, 128, 128);
+        assembly ("memory-safe") {
+            let p := add(add(dst, 0x20), i)
+            mstore(p, header)
+            mstore(add(p, 0x0c), mload(value))
+            mstore(add(p, 0x2c), mload(add(value, 0x20)))
+            mstore(add(p, 0x4c), mload(add(value, 0x40)))
+            mstore(add(p, 0x6c), mload(add(value, 0x60)))
+        }
+    }
+
+    function appendCustody(Writer memory writer, uint host, bytes32 asset, bytes32 meta, uint amount) internal pure {
+        appendCustody(writer, HostAmount(host, asset, meta, amount));
+    }
+
+    function appendCustody(Writer memory writer, HostAmount memory value) internal pure {
+        writer.i = writeCustodyBlock(writer.dst, writer.i, value);
+    }
+
+    function writeTxBlock(bytes memory dst, uint i, Tx memory value) internal pure returns (uint next) {
+        next = i + TX_BLOCK_LEN;
+        if (next > dst.length) revert WriterOverflow();
+        uint header = toBlockHeader(TX_KEY, 160, 160);
+        assembly ("memory-safe") {
+            let p := add(add(dst, 0x20), i)
+            mstore(p, header)
+            mstore(add(p, 0x0c), mload(value))
+            mstore(add(p, 0x2c), mload(add(value, 0x20)))
+            mstore(add(p, 0x4c), mload(add(value, 0x40)))
+            mstore(add(p, 0x6c), mload(add(value, 0x60)))
+            mstore(add(p, 0x8c), mload(add(value, 0x80)))
+        }
+    }
+
+    function appendTx(Writer memory writer, Tx memory value) internal pure {
+        writer.i = writeTxBlock(writer.dst, writer.i, value);
+    }
+
+    function done(Writer memory writer) internal pure returns (bytes memory) {
+        if (writer.i != writer.dst.length) revert IncompleteWriter();
+        return writer.dst;
+    }
+
+    function finish(Writer memory writer) internal pure returns (bytes memory out) {
+        if (writer.i == 0) revert EmptyRequest();
+        if (writer.i > writer.dst.length) revert IncompleteWriter();
+        out = writer.dst;
+        assembly ("memory-safe") {
+            mstore(out, mload(writer))
+        }
+    }
+}

package/contracts/combinators/AmountToBalance.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AMOUNT_KEY, AssetAmount} from "../Schema.sol";
+import {Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+abstract contract AmountToBalance {
+    function amountToBalance(bytes32 account, AssetAmount memory amount) internal virtual returns (AssetAmount memory);
+
+    function amountsToBalances(bytes calldata blocks, uint i, bytes32 account) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(blocks, i, AMOUNT_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(blocks, i);
+            AssetAmount memory amount = ref.toAmountValue(blocks);
+            AssetAmount memory out = amountToBalance(account, amount);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/combinators/AmountToCustody.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AMOUNT_KEY, HostAmount} from "../Schema.sol";
+import {Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+abstract contract AmountToCustody {
+    function amountToCustody(
+        uint host,
+        bytes32 account,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount
+    ) internal virtual returns (HostAmount memory);
+
+    function amountsToCustodies(
+        bytes calldata blocks,
+        uint i,
+        uint host,
+        bytes32 account
+    ) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocCustodiesFrom(blocks, i, AMOUNT_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(blocks, i);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount(blocks);
+            HostAmount memory out = amountToCustody(host, account, asset, meta, amount);
+            if (out.amount > 0) writer.appendCustody(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/combinators/CustodyToBalance.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AssetAmount, HostAmount, CUSTODY_KEY, ROUTE_KEY} from "../Schema.sol";
+import {Blocks, BlockRef, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract CustodyToBalance {
+    function custodyToBalance(bytes32 account, HostAmount memory custody) internal virtual returns (AssetAmount memory);
+
+    function custodiesToBalances(bytes calldata blocks, uint i, bytes32 account) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(blocks, i, CUSTODY_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(blocks, i);
+            HostAmount memory custody = ref.toCustodyValue(blocks);
+            AssetAmount memory out = custodyToBalance(account, custody);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/combinators/EachRoute.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {ROUTE_KEY} from "../Schema.sol";
+import {Data, DataRef} from "../Blocks.sol";
+
+abstract contract EachRoute {
+    function eachRoute(DataRef memory rawRoute) internal virtual;
+
+    function forEachRoute(bytes calldata blocks, uint i) internal returns (uint) {
+        while (i < blocks.length) {
+            (DataRef memory ref, uint next) = Data.from(blocks, i);
+            if (ref.key != ROUTE_KEY) return i;
+            eachRoute(ref);
+            i = next;
+        }
+        return i;
+    }
+}

package/contracts/combinators/MapBalance.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AssetAmount, BALANCE_KEY} from "../Schema.sol";
+import {Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+abstract contract MapBalance {
+    function mapBalance(bytes32 account, AssetAmount memory balance) internal virtual returns (AssetAmount memory out);
+
+    function mapBalances(bytes calldata state, uint i, bytes32 account) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(state, i, BALANCE_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(state, i);
+            AssetAmount memory balance = ref.toBalanceValue(state);
+            AssetAmount memory out = mapBalance(account, balance);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/combinators/MapCustody.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CUSTODY_KEY, HostAmount} from "../Schema.sol";
+import {Blocks, BlockRef, Writers, Writer} from "../Blocks.sol";
+
+using Blocks for BlockRef;
+using Writers for Writer;
+
+abstract contract MapCustody {
+    function mapCustody(bytes32 account, HostAmount memory custody) internal virtual returns (HostAmount memory out);
+
+    function mapCustodies(bytes calldata state, uint i, bytes32 account) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocCustodiesFrom(state, i, CUSTODY_KEY);
+
+        while (i < end) {
+            BlockRef memory ref = Blocks.from(state, i);
+            HostAmount memory custody = ref.toCustodyValue(state);
+            HostAmount memory out = mapCustody(account, custody);
+            if (out.amount > 0) writer.appendCustody(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/combinators/RouteToBalance.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {ROUTE_KEY} from "../Schema.sol";
+import {Data, DataRef, Writers, Writer} from "../Blocks.sol";
+
+using Writers for Writer;
+
+abstract contract RouteToBalance {
+    function routeToBalance(
+        bytes32 account,
+        DataRef memory rawRoute
+    ) internal virtual returns (bytes32 asset, bytes32 meta, uint amount);
+
+    function routesToBalances(bytes calldata blocks, uint i, bytes32 account) internal returns (bytes memory) {
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(blocks, i, ROUTE_KEY);
+
+        while (i < end) {
+            DataRef memory route;
+            (route, i) = Data.routeFrom(blocks, i);
+            (bytes32 asset, bytes32 meta, uint amount) = routeToBalance(account, route);
+            if (amount > 0) writer.appendBalance(asset, meta, amount);
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Base.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {OperationBase} from "../core/Operation.sol";
+import {CommandEvent} from "../events/Command.sol";
+import {toCommandId, toCommandSelector} from "../utils/Ids.sol";
+
+struct CommandContext {
+    uint target;
+    bytes32 account;
+    bytes state;
+    bytes request;
+}
+
+abstract contract CommandBase is OperationBase, CommandEvent {
+    error Expired();
+    error NotAdmin(bytes32 value);
+    error UnexpectedEndpoint();
+
+    modifier onlyAdmin(bytes32 account) {
+        if (account != adminAccount) revert NotAdmin(account);
+        _;
+    }
+
+    modifier onlyCommand(uint cid, uint target) {
+        if (target != 0 && target != cid) revert UnexpectedEndpoint();
+        enforceCaller(msg.sender);
+        _;
+    }
+
+    modifier onlyActive(uint deadline) {
+        if (deadline < block.timestamp) revert Expired();
+        _;
+    }
+
+    function commandId(string memory name) internal view returns (uint) {
+        return toCommandId(toCommandSelector(name), address(this));
+    }
+}

package/contracts/commands/Borrow.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, AMOUNT, BALANCE_KEY, CUSTODY_KEY, Blocks, BlockRef, Data, DataRef, Writers, Writer} from "../Blocks.sol";
+import {routeSchema1} from "../utils/Utils.sol";
+
+string constant BABTB = "borrowAgainstBalanceToBalance";
+string constant BACTB = "borrowAgainstCustodyToBalance";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+
+abstract contract BorrowAgainstCustodyToBalance is CommandBase {
+    uint internal immutable borrowAgainstCustodyToBalanceId = commandId(BACTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = routeSchema1(maybeRoute, AMOUNT);
+        emit Command(host, BACTB, schema, borrowAgainstCustodyToBalanceId, CUSTODIES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested borrow amount from rawRoute.innerAmount()
+    function borrowAgainstCustodyToBalance(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute
+    ) internal virtual returns (AssetAmount memory);
+
+    function borrowAgainstCustodyToBalance(
+        CommandContext calldata c
+    ) external payable onlyCommand(borrowAgainstCustodyToBalanceId, 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 = borrowAgainstCustodyToBalance(c.account, custody, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract BorrowAgainstBalanceToBalance is CommandBase {
+    uint internal immutable borrowAgainstBalanceToBalanceId = commandId(BABTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = routeSchema1(maybeRoute, AMOUNT);
+        emit Command(host, BABTB, schema, borrowAgainstBalanceToBalanceId, BALANCES, BALANCES);
+    }
+
+    // @dev implementation extracts the requested borrow amount from rawRoute.innerAmount()
+    function borrowAgainstBalanceToBalance(
+        bytes32 account,
+        AssetAmount memory balance,
+        DataRef memory rawRoute
+    ) internal virtual returns (AssetAmount memory);
+
+    function borrowAgainstBalanceToBalance(
+        CommandContext calldata c
+    ) external payable onlyCommand(borrowAgainstBalanceToBalanceId, 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 = borrowAgainstBalanceToBalance(c.account, balance, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.end;
+        }
+
+        return writer.finish();
+    }
+}