@rootzero/contracts 0.6.2 → 0.7.0

package/peer/DenyAssets.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {PeerBase} from "./Base.sol";
+import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
 import {Cursors, Cur, Schemas} from "../Cursors.sol";
 
 using Cursors for Cur;
@@ -10,27 +11,21 @@ string constant NAME = "peerDenyAssets";
 
 /// @title PeerDenyAssets
 /// @notice Peer that blocks a list of (asset, meta) pairs on behalf of a remote host.
-/// Each ASSET block in the request calls `peerDenyAsset`. Restricted to trusted peers.
-abstract contract PeerDenyAssets is PeerBase {
+/// Each ASSET block in the request calls `denyAsset`. Restricted to trusted peers.
+abstract contract PeerDenyAssets is PeerBase, DenyAssetsHook {
     uint internal immutable peerDenyAssetsId = peerId(NAME);
 
     constructor() {
         emit Peer(host, NAME, Schemas.Asset, peerDenyAssetsId, false);
     }
 
-    /// @notice Override to block a single (asset, meta) pair.
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @return True if the asset was newly denied, false if it was already denied.
-    function peerDenyAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
-
     /// @notice Execute the deny-assets peer call.
     function peerDenyAssets(bytes calldata request) external onlyPeer returns (bytes memory) {
         (Cur memory assets, , ) = cursor(request, 1);
 
         while (assets.i < assets.bound) {
             (bytes32 asset, bytes32 meta) = assets.unpackAsset();
-            peerDenyAsset(asset, meta);
+            denyAsset(asset, meta);
         }
 
         assets.complete();

package/peer/Pull.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { PeerBase } from "./Base.sol";
-import { Cursors, Cur } from "../Cursors.sol";
+import {PeerBase} from "./Base.sol";
+import {Cursors, Cur} from "../Cursors.sol";
 
 string constant NAME = "peerPull";
 
@@ -10,7 +10,8 @@ using Cursors for Cur;
 
 /// @title PeerPull
 /// @notice Peer that pulls assets from a remote host into this one.
-/// Each block in the request is dispatched to `peerPull(Cur)`. Restricted to trusted peers.
+/// Each block in the request is dispatched to `peerPull(peer, input)`, where `peer`
+/// is derived from `msg.sender`. Restricted to trusted peers.
 abstract contract PeerPull is PeerBase {
     uint internal immutable peerPullId = peerId(NAME);
 
@@ -19,24 +20,20 @@ abstract contract PeerPull is PeerBase {
     }
 
     /// @notice Override to process a single incoming block from the pull request.
+    /// @param peer Host node ID derived from the caller address.
     /// @param input Cursor positioned at the current input block; advance it before returning.
-    function peerPull(Cur memory input) internal virtual;
+    function peerPull(uint peer, Cur memory input) internal virtual;
 
     /// @notice Execute the pull peer call.
     function peerPull(bytes calldata request) external onlyPeer returns (bytes memory) {
         (Cur memory input, , ) = cursor(request, 1);
+        uint peer = caller();
 
         while (input.i < input.bound) {
-            peerPull(input);
+            peerPull(peer, input);
         }
 
         input.complete();
         return "";
     }
 }
-
-
-
-
-
-

package/peer/Push.sol

@@ -10,7 +10,8 @@ using Cursors for Cur;
 
 /// @title PeerPush
 /// @notice Peer that receives assets pushed from a remote host into this one.
-/// Each block in the request is dispatched to `peerPush(Cur)`. Restricted to trusted peers.
+/// Each block in the request is dispatched to `peerPush(peer, input)`, where `peer`
+/// is derived from `msg.sender`. Restricted to trusted peers.
 abstract contract PeerPush is PeerBase {
     uint internal immutable peerPushId = peerId(NAME);
 
@@ -19,15 +20,17 @@ abstract contract PeerPush is PeerBase {
     }
 
     /// @notice Override to process a single incoming block from the push request.
+    /// @param peer Host node ID derived from the caller address.
     /// @param input Cursor positioned at the current input block; advance it before returning.
-    function peerPush(Cur memory input) internal virtual;
+    function peerPush(uint peer, Cur memory input) internal virtual;
 
     /// @notice Execute the push peer call.
     function peerPush(bytes calldata request) external onlyPeer returns (bytes memory) {
         (Cur memory input, , ) = cursor(request, 1);
+        uint peer = caller();
 
         while (input.i < input.bound) {
-            peerPush(input);
+            peerPush(peer, input);
         }
 
         input.complete();

package/queries/Assets.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Cur, Cursors, Writer, Writers, Keys} from "../Cursors.sol";
+import {Schemas} from "../blocks/Schema.sol";
+import {QueryBase} from "./Base.sol";
+
+using Cursors for Cur;
+
+string constant NAME = "isAllowedAsset";
+string constant OUTPUT = "response(uint allowed)";
+
+/// @title IsAllowedAsset
+/// @notice Rootzero query that checks whether one or more `(asset, meta)` tuples are allowed.
+/// The request is a run of `ASSET` blocks.
+/// The response returns one `RESPONSE` block per query entry, preserving request order.
+abstract contract IsAllowedAsset is QueryBase {
+    uint public immutable isAllowedAssetId = queryId(NAME);
+
+    constructor() {
+        emit Query(host, NAME, Schemas.Asset, OUTPUT, isAllowedAssetId);
+    }
+
+    /// @notice Resolve whether one asset tuple is allowed.
+    /// Concrete implementations define the allowlist policy.
+    /// @param asset Requested asset identifier.
+    /// @param meta Requested asset metadata slot.
+    /// @return allowed Whether the asset tuple is allowed.
+    function isAllowedAsset(bytes32 asset, bytes32 meta) internal view virtual returns (bool allowed);
+
+    /// @notice Resolve allowlist status for a run of requested `(asset, meta)` tuples.
+    /// @param request Block-stream request consisting of `asset(asset, meta)*`.
+    /// @return Block-stream response containing one `response(allowed)` per asset block.
+    function isAllowedAsset(bytes calldata request) external view returns (bytes memory) {
+        (Cur memory query, uint count, ) = cursor(request, 1);
+        Writer memory response = Writers.alloc32s(count);
+
+        while (query.i < query.bound) {
+            (bytes32 asset, bytes32 meta) = query.unpackAsset();
+            bool allowed = isAllowedAsset(asset, meta);
+            Writers.appendBool(response, Keys.Response, allowed);
+        }
+
+        return query.complete(response);
+    }
+}

package/queries/Balances.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Cur, Cursors, Schemas, Writer, Writers} from "../Cursors.sol";
+import {QueryBase} from "./Base.sol";
+
+using Cursors for Cur;
+
+string constant NAME = "getBalances";
+string constant INPUT = "query(bytes32 account, bytes32 asset, bytes32 meta)";
+
+/// @title GetBalances
+/// @notice Rootzero query that resolves balances for one or more `(account, asset, meta)` tuples.
+/// The request is a run of `QUERY` blocks, each encoding `(bytes32 account, bytes32 asset, bytes32 meta)`.
+/// The response returns one `BALANCE` block per query entry, preserving request order.
+abstract contract GetBalances is QueryBase {
+    uint public immutable getBalancesId = queryId(NAME);
+
+    constructor() {
+        emit Query(host, NAME, INPUT, Schemas.Balance, getBalancesId);
+    }
+
+    /// @notice Resolve one account's balance for one supported asset.
+    /// Concrete implementations define how assets are resolved.
+    /// @param account Account identifier carried by the query payload.
+    /// @param asset Requested asset identifier.
+    /// @param meta Requested asset metadata slot.
+    /// @return amount Current balance in the asset's native units.
+    function getBalance(bytes32 account, bytes32 asset, bytes32 meta) internal view virtual returns (uint amount);
+
+    /// @notice Resolve balances for a run of requested `(account, asset, meta)` tuples.
+    /// @param request Block-stream request consisting of `query(account, asset, meta)*`.
+    /// @return Block-stream response containing one `balance(asset, meta, amount)` per query block.
+    function getBalances(bytes calldata request) external view returns (bytes memory) {
+        (Cur memory query, uint count, ) = cursor(request, 1);
+        Writer memory response = Writers.allocBalances(count);
+
+        while (query.i < query.bound) {
+            (bytes32 account, bytes32 asset, bytes32 meta) = query.unpackQuery96();
+            uint balance = getBalance(account, asset, meta);
+            Writers.appendBalance(response, asset, meta, balance);
+        }
+
+        return query.complete(response);
+    }
+}

package/queries/Base.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CursorBase } from "../core/CursorBase.sol";
+import { HostBound } from "../core/HostBound.sol";
+import { QueryEvent } from "../events/Query.sol";
+import { Ids, Selectors } from "../utils/Ids.sol";
+
+/// @notice ABI-encode a query call from a target query ID and request block stream.
+/// @dev Derives the function selector from `target` via `Ids.querySelector(target)`.
+/// Reverts if `target` is not a valid query ID.
+/// @param target Destination query node ID embedding the target selector.
+/// @param request Input block stream for the query invocation.
+/// @return ABI-encoded calldata for the query entry point.
+function encodeQueryCall(uint target, bytes calldata request) pure returns (bytes memory) {
+    bytes4 selector = Ids.querySelector(target);
+    return abi.encodeWithSelector(selector, request);
+}
+
+/// @title QueryBase
+/// @notice Abstract base for rootzero query contracts.
+/// Queries are view-only entry points that consume a block-stream request and
+/// return a block-stream response.
+abstract contract QueryBase is HostBound, CursorBase, QueryEvent {
+
+    /// @notice Derive the deterministic node ID for a named query on this contract.
+    /// The ID encodes the ABI selector of `name(bytes)` and `address(this)`,
+    /// making it unique per (function name, contract address) pair.
+    /// @param name Query function name (without argument list).
+    /// @return Query node ID.
+    function queryId(string memory name) internal view returns (uint) {
+        return Ids.toQuery(Selectors.query(name), address(this));
+    }
+}

package/queries/Positions.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Cur, Cursors, Writer, Writers, Keys} from "../Cursors.sol";
+import {Schemas} from "../blocks/Schema.sol";
+import {QueryBase} from "./Base.sol";
+
+using Cursors for Cur;
+
+string constant NAME = "getAssetPosition";
+
+/// @title PositionsQuery
+/// @notice Rootzero query that resolves one dynamic position response for each requested asset tuple.
+/// The request is a run of `ASSET` blocks.
+/// The response returns one dynamic `RESPONSE` block per asset entry, preserving request order.
+abstract contract AssetPosition is QueryBase {
+    uint public immutable getAssetPositionId = queryId(NAME);
+    uint internal immutable positionResponseSize;
+
+    constructor(string memory output, uint responseSize) {
+        positionResponseSize = responseSize;
+        emit Query(host, NAME, Schemas.Asset, output, getAssetPositionId);
+    }
+
+    /// @notice Resolve the position payload for one requested asset tuple.
+    /// Concrete implementations must append exactly one `RESPONSE` block whose payload
+    /// length matches `positionResponseSize`.
+    /// @param asset Requested asset identifier.
+    /// @param meta Requested asset metadata slot.
+    /// @param response Destination writer for the response stream.
+    function appendAssetPosition(bytes32 asset, bytes32 meta, Writer memory response) internal view virtual;
+
+    /// @notice Resolve positions for a run of requested `(asset, meta)` tuples.
+    /// @dev Allocates from the configured fixed response payload length so each hook call
+    ///      can append one `RESPONSE` block directly into the output stream.
+    /// @param request Block-stream request consisting of `asset(asset, meta)*`.
+    /// @return Block-stream response containing one `response(bytes data)` block per asset block.
+    function getAssetPosition(bytes calldata request) external view returns (bytes memory) {
+        (Cur memory query, uint count, ) = cursor(request, 1);
+        Writer memory response = Writers.allocBytes(count, positionResponseSize);
+
+        while (query.i < query.bound) {
+            (bytes32 asset, bytes32 meta) = query.unpackAsset();
+            appendAssetPosition(asset, meta, response);
+        }
+
+        return query.complete(response);
+    }
+}

package/utils/Ids.sol

@@ -24,6 +24,8 @@ library Ids {
     uint32 constant Command = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Command);
     /// @dev Full 4-byte type prefix for peer nodes.
     uint32 constant Peer = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Peer);
+    /// @dev Full 4-byte type prefix for query nodes.
+    uint32 constant Query = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Query);
 
     /// @notice Return true if `id` is a host node ID.
     function isHost(uint id) internal pure returns (bool) {
@@ -40,6 +42,11 @@ library Ids {
         return uint32(id >> 224) == Peer;
     }
 
+    /// @notice Return true if `id` is a query node ID.
+    function isQuery(uint id) internal pure returns (bool) {
+        return uint32(id >> 224) == Query;
+    }
+
     /// @notice Assert that `id` is a command ID and return it unchanged.
     /// @param id Node ID to validate.
     /// @return cid The same `id` value if it is a command.
@@ -48,6 +55,46 @@ library Ids {
         return id;
     }
 
+    /// @notice Assert that `id` is a command ID and return its embedded ABI selector.
+    /// @param id Node ID to validate.
+    /// @return selector 4-byte command selector stored in bits [191:160].
+    function commandSelector(uint id) internal pure returns (bytes4 selector) {
+        if (!isCommand(id)) revert InvalidId();
+        return bytes4(uint32(id >> 160));
+    }
+
+    /// @notice Assert that `id` is a peer ID and return it unchanged.
+    /// @param id Node ID to validate.
+    /// @return pid The same `id` value if it is a peer.
+    function peer(uint id) internal pure returns (uint pid) {
+        if (!isPeer(id)) revert InvalidId();
+        return id;
+    }
+
+    /// @notice Assert that `id` is a peer ID and return its embedded ABI selector.
+    /// @param id Node ID to validate.
+    /// @return selector 4-byte peer selector stored in bits [191:160].
+    function peerSelector(uint id) internal pure returns (bytes4 selector) {
+        if (!isPeer(id)) revert InvalidId();
+        return bytes4(uint32(id >> 160));
+    }
+
+    /// @notice Assert that `id` is a query ID and return it unchanged.
+    /// @param id Node ID to validate.
+    /// @return qid The same `id` value if it is a query.
+    function query(uint id) internal pure returns (uint qid) {
+        if (!isQuery(id)) revert InvalidId();
+        return id;
+    }
+
+    /// @notice Assert that `id` is a query ID and return its embedded ABI selector.
+    /// @param id Node ID to validate.
+    /// @return selector 4-byte query selector stored in bits [191:160].
+    function querySelector(uint id) internal pure returns (bytes4 selector) {
+        if (!isQuery(id)) revert InvalidId();
+        return bytes4(uint32(id >> 160));
+    }
+
     /// @notice Assert that `id` is the host ID of `target` on the current chain.
     /// @param id Node ID to validate.
     /// @param target Expected host contract address.
@@ -84,6 +131,16 @@ library Ids {
         return id;
     }
 
+    /// @notice Build a chain-local query ID for the given selector and contract.
+    /// @param selector 4-byte ABI selector of the query entry point.
+    /// @param target Query contract address.
+    /// @return Query node ID embedding both the selector and address.
+    function toQuery(bytes4 selector, address target) internal view returns (uint) {
+        uint id = toLocalBase(Query) | uint(uint160(target));
+        id |= uint(uint32(selector)) << 160;
+        return id;
+    }
+
     /// @notice Extract the contract address from any local node ID.
     /// Reverts if `id` does not belong to the local node family.
     /// @param id Node ID (host, command, or peer).
@@ -104,12 +161,14 @@ library Ids {
 }
 
 /// @title Selectors
-/// @notice ABI-selector derivation helpers for command and peer dispatch.
+/// @notice ABI-selector derivation helpers for command, peer, and query dispatch.
 library Selectors {
     /// @dev ABI argument encoding for command entry points: `((uint256,bytes32,bytes,bytes))`.
     string constant CommandArgs = "((uint256,bytes32,bytes,bytes))";
     /// @dev ABI argument encoding for peer entry points: `(bytes)`.
     string constant PeerArgs = "(bytes)";
+    /// @dev ABI argument encoding for query entry points: `(bytes)`.
+    string constant QueryArgs = "(bytes)";
 
     /// @notice Derive the 4-byte ABI selector for a named command.
     /// The selector is `keccak256(name ++ CommandArgs)[0:4]`.
@@ -126,4 +185,12 @@ library Selectors {
     function peer(string memory name) internal pure returns (bytes4) {
         return bytes4(keccak256(bytes.concat(bytes(name), bytes(PeerArgs))));
     }
+
+    /// @notice Derive the 4-byte ABI selector for a named query.
+    /// The selector is `keccak256(name ++ QueryArgs)[0:4]`.
+    /// @param name Query function name (without arguments).
+    /// @return 4-byte selector.
+    function query(string memory name) internal pure returns (bytes4) {
+        return bytes4(keccak256(bytes.concat(bytes(name), bytes(QueryArgs))));
+    }
 }

package/utils/Layout.sol

@@ -52,6 +52,8 @@ library Layout {
     uint8 constant Command = 0x02;
     /// @dev Node is a peer contract.
     uint8 constant Peer = 0x03;
+    /// @dev Node is a query contract.
+    uint8 constant Query = 0x04;
 
     // -------------------------------------------------------------------------
     // Asset subtype tags (uint8, fourth byte of the ID type field)

package/commands/Borrow.sol

@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import { CommandContext, CommandBase, State } from "./Base.sol";
-import { AssetAmount, HostAmount, Cur, Cursors, Writer, Writers } from "../Cursors.sol";
-
-string constant BABTB = "borrowAgainstBalanceToBalance";
-string constant BACTB = "borrowAgainstCustodyToBalance";
-
-using Cursors for Cur;
-using Writers for Writer;
-
-/// @title BorrowAgainstCustodyToBalance
-/// @notice Command that issues loans against CUSTODY state positions, emitting BALANCE outputs.
-abstract contract BorrowAgainstCustodyToBalance is CommandBase {
-    uint internal immutable borrowAgainstCustodyToBalanceId = commandId(BACTB);
-
-    constructor(string memory input) {
-        emit Command(host, BACTB, input, borrowAgainstCustodyToBalanceId, State.Custodies, State.Balances, false);
-    }
-
-    /// @dev Override to borrow against a custody position.
-    /// `request` is the live auxiliary request cursor for this command;
-    /// implementations validate and unpack it as needed.
-    function borrowAgainstCustodyToBalance(
-        bytes32 account,
-        HostAmount memory custody,
-        Cur memory request
-    ) internal virtual returns (AssetAmount memory);
-
-    function borrowAgainstCustodyToBalance(
-        CommandContext calldata c
-    ) external onlyCommand(borrowAgainstCustodyToBalanceId, c.target) returns (bytes memory) {
-        (Cur memory state, uint stateCount, ) = cursor(c.state, 1);
-        Cur memory request = cursor(c.request);
-        Writer memory writer = Writers.allocBalances(stateCount);
-
-        while (state.i < state.bound) {
-            HostAmount memory custody = state.unpackCustodyValue();
-            AssetAmount memory out = borrowAgainstCustodyToBalance(c.account, custody, request);
-            writer.appendNonZeroBalance(out);
-        }
-
-        return state.complete(writer);
-    }
-}
-
-/// @title BorrowAgainstBalanceToBalance
-/// @notice Command that issues loans against BALANCE state positions, emitting BALANCE outputs.
-abstract contract BorrowAgainstBalanceToBalance is CommandBase {
-    uint internal immutable borrowAgainstBalanceToBalanceId = commandId(BABTB);
-
-    constructor(string memory input) {
-        emit Command(host, BABTB, input, borrowAgainstBalanceToBalanceId, State.Balances, State.Balances, false);
-    }
-
-    /// @dev Override to borrow against a balance position.
-    /// `request` is the live auxiliary request cursor for this command;
-    /// implementations validate and unpack it as needed.
-    function borrowAgainstBalanceToBalance(
-        bytes32 account,
-        AssetAmount memory balance,
-        Cur memory request
-    ) internal virtual returns (AssetAmount memory);
-
-    function borrowAgainstBalanceToBalance(
-        CommandContext calldata c
-    ) external onlyCommand(borrowAgainstBalanceToBalanceId, c.target) returns (bytes memory) {
-        (Cur memory state, uint stateCount, ) = cursor(c.state, 1);
-        Cur memory request = cursor(c.request);
-        Writer memory writer = Writers.allocBalances(stateCount);
-
-        while (state.i < state.bound) {
-            AssetAmount memory balance = state.unpackBalanceValue();
-            AssetAmount memory out = borrowAgainstBalanceToBalance(c.account, balance, request);
-            writer.appendNonZeroBalance(out);
-        }
-
-        return state.complete(writer);
-    }
-}
-
-
-
-
-
-
-
-

package/commands/Liquidate.sol

@@ -1,99 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {CommandContext, CommandBase, State} from "./Base.sol";
-import {AssetAmount, HostAmount, Cur, Cursors, Writers, Writer} from "../Cursors.sol";
-
-string constant LFBTB = "liquidateFromBalanceToBalances";
-string constant LFCTB = "liquidateFromCustodyToBalances";
-
-using Cursors for Cur;
-using Writers for Writer;
-
-/// @title LiquidateFromBalanceToBalances
-/// @notice Command that liquidates BALANCE state positions into BALANCE outputs
-/// using a virtual hook. The output-to-input ratio is set at construction via `scaledRatio`.
-abstract contract LiquidateFromBalanceToBalances is CommandBase {
-    uint internal immutable liquidateFromBalanceToBalancesId = commandId(LFBTB);
-    uint private immutable outScale;
-
-    constructor(string memory input, uint scaledRatio) {
-        outScale = scaledRatio;
-        emit Command(host, LFBTB, input, liquidateFromBalanceToBalancesId, State.Balances, State.Balances, false);
-    }
-
-    /// @dev Override to liquidate using a balance repayment amount.
-    /// `request` may be ignored by implementations that don't need it.
-    /// Implementations validate and unpack it as needed, and may append
-    /// BALANCE outputs to `out` within the capacity implied by this command's
-    /// configured `scaledRatio`.
-    function liquidateFromBalanceToBalances(
-        bytes32 account,
-        AssetAmount memory balance,
-        Cur memory request,
-        Writer memory out
-    ) internal virtual;
-
-    function liquidateFromBalanceToBalances(
-        CommandContext calldata c
-    ) external onlyCommand(liquidateFromBalanceToBalancesId, c.target) returns (bytes memory) {
-        (Cur memory state, uint stateCount, ) = cursor(c.state, 1);
-        Cur memory request = cursor(c.request);
-        Writer memory writer = Writers.allocScaledBalances(stateCount, outScale);
-
-        while (state.i < state.bound) {
-            AssetAmount memory balance = state.unpackBalanceValue();
-            liquidateFromBalanceToBalances(c.account, balance, request, writer);
-        }
-
-        return state.complete(writer);
-    }
-}
-
-/// @title LiquidateFromCustodyToBalances
-/// @notice Command that liquidates CUSTODY state positions into BALANCE outputs
-/// using a virtual hook. The output-to-input ratio is set at construction via `scaledRatio`.
-abstract contract LiquidateFromCustodyToBalances is CommandBase {
-    uint internal immutable liquidateFromCustodyToBalancesId = commandId(LFCTB);
-    uint private immutable outScale;
-
-    constructor(string memory input, uint scaledRatio) {
-        outScale = scaledRatio;
-        emit Command(host, LFCTB, input, liquidateFromCustodyToBalancesId, State.Custodies, State.Balances, false);
-    }
-
-    /// @dev Override to liquidate using a custody repayment amount.
-    /// `request` may be ignored by implementations that don't need it.
-    /// Implementations validate and unpack it as needed, and may append
-    /// BALANCE outputs to `out` within the capacity implied by this command's
-    /// configured `scaledRatio`.
-    function liquidateFromCustodyToBalances(
-        bytes32 account,
-        HostAmount memory custody,
-        Cur memory request,
-        Writer memory out
-    ) internal virtual;
-
-    function liquidateFromCustodyToBalances(
-        CommandContext calldata c
-    ) external onlyCommand(liquidateFromCustodyToBalancesId, c.target) returns (bytes memory) {
-        (Cur memory state, uint stateCount, ) = cursor(c.state, 1);
-        Cur memory request = cursor(c.request);
-        Writer memory writer = Writers.allocScaledBalances(stateCount, outScale);
-
-        while (state.i < state.bound) {
-            HostAmount memory custody = state.unpackCustodyValue();
-            liquidateFromCustodyToBalances(c.account, custody, request, writer);
-        }
-
-        return state.complete(writer);
-    }
-}
-
-
-
-
-
-
-
-