@rootzero/contracts 0.2.0

package/contracts/commands/Base.sol

@@ -0,0 +1,40 @@
+// 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 { Channels } from "../utils/Channels.sol";
+import { Ids, Selectors } 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 Ids.toCommand(Selectors.command(name), address(this));
+    }
+}

package/contracts/commands/Borrow.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { AssetAmount, HostAmount, Schemas, Blocks, Block, Writers, Writer, Keys } from "../Blocks.sol";
+
+string constant BABTB = "borrowAgainstBalanceToBalance";
+string constant BACTB = "borrowAgainstCustodyToBalance";
+
+using Blocks for Block;
+using Writers for Writer;
+
+abstract contract BorrowAgainstCustodyToBalance is CommandBase {
+    uint internal immutable borrowAgainstCustodyToBalanceId = commandId(BACTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = Schemas.route1(maybeRoute, Schemas.Amount);
+        emit Command(host, BACTB, schema, borrowAgainstCustodyToBalanceId, Channels.Custodies, Channels.Balances);
+    }
+
+    /// @dev Override to borrow against a custody position.
+    /// Implementations extract the requested borrow amount from
+    /// `rawRoute.innerAmount()`.
+    function borrowAgainstCustodyToBalance(
+        bytes32 account,
+        HostAmount memory custody,
+        Block 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, Keys.Custody);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            Block memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue();
+            AssetAmount memory out = borrowAgainstCustodyToBalance(c.account, custody, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.cursor;
+        }
+
+        return writer.finish();
+    }
+}
+
+abstract contract BorrowAgainstBalanceToBalance is CommandBase {
+    uint internal immutable borrowAgainstBalanceToBalanceId = commandId(BABTB);
+
+    constructor(string memory maybeRoute) {
+        string memory schema = Schemas.route1(maybeRoute, Schemas.Amount);
+        emit Command(host, BABTB, schema, borrowAgainstBalanceToBalanceId, Channels.Balances, Channels.Balances);
+    }
+
+    /// @dev Override to borrow against a balance position.
+    /// Implementations extract the requested borrow amount from
+    /// `rawRoute.innerAmount()`.
+    function borrowAgainstBalanceToBalance(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block 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, Keys.Balance);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            Block memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue();
+            AssetAmount memory out = borrowAgainstBalanceToBalance(c.account, balance, route);
+            writer.appendNonZeroBalance(out);
+            i = ref.cursor;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Burn.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandBase, CommandContext, Channels } from "./Base.sol";
+import { Blocks, Block, Keys } from "../Blocks.sol";
+using Blocks for Block;
+
+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, Channels.Balances, Channels.Setup);
+    }
+
+    /// @dev Override to burn or consume the provided balance amount.
+    /// Called once per BALANCE block in state.
+    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) {
+            Block memory ref = Blocks.from(c.state, i);
+            if (ref.key != Keys.Balance) break;
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackBalance();
+            burn(c.account, asset, meta, amount);
+            i = ref.cursor;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/Create.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandBase, CommandContext, Channels } from "./Base.sol";
+import { Blocks, Block, Keys } from "../Blocks.sol";
+using Blocks for Block;
+
+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, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to create or initialize an object described by `rawRoute`.
+    /// Called once per ROUTE block in the request.
+    function create(bytes32 account, Block 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) {
+            Block memory ref = Blocks.from(c.request, q);
+            if (ref.key != Keys.Route) break;
+            create(c.account, ref);
+            q = ref.cursor;
+        }
+
+        return done(0, q);
+    }
+}

package/contracts/commands/Credit.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandBase, CommandContext, Channels } from "./Base.sol";
+import { Keys, Schemas, Blocks, Block } from "../Blocks.sol";
+string constant NAME = "creditAccount";
+
+using Blocks for Block;
+
+abstract contract CreditAccount is CommandBase {
+    uint internal immutable creditAccountId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Recipient, creditAccountId, Channels.Balances, Channels.Setup);
+    }
+
+    /// @dev Override to credit externally managed funds to `account`.
+    /// Called once per BALANCE block in state.
+    function creditAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function creditAccount(
+        CommandContext calldata c
+    ) external payable onlyCommand(creditAccountId, 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) {
+            Block memory ref = Blocks.from(c.state, i);
+            if (ref.key != Keys.Balance) break;
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackBalance();
+            creditAccount(to, asset, meta, amount);
+            i = ref.cursor;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/Debit.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { Writer, Keys, Schemas, Blocks, Block, Writers } from "../Blocks.sol";
+
+string constant NAME = "debitAccount";
+
+using Blocks for Block;
+using Writers for Writer;
+
+abstract contract DebitAccount is CommandBase {
+    uint internal immutable debitAccountId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Amount, debitAccountId, Channels.Setup, Channels.Balances);
+    }
+
+    /// @dev Override to debit externally managed funds from `account`.
+    /// Called once per AMOUNT block before a matching BALANCE is emitted.
+    function debitAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    /// @dev Override to customize request parsing or batching for debits.
+    /// The default implementation iterates AMOUNT blocks, calls
+    /// `debitAccount`, and emits matching BALANCE blocks.
+    function debitAccount(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
+        uint q = 0;
+        (Writer memory writer, uint end) = Writers.allocBalancesFrom(request, q, Keys.Amount);
+
+        while (q < end) {
+            Block memory ref = Blocks.from(request, q);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount();
+            debitAccount(from, asset, meta, amount);
+            writer.appendBalance(asset, meta, amount);
+            q = ref.cursor;
+        }
+
+        return writer.done();
+    }
+
+    function debitAccount(
+        CommandContext calldata c
+    ) external payable onlyCommand(debitAccountId, c.target) returns (bytes memory) {
+        return debitAccount(c.account, c.request);
+    }
+}

package/contracts/commands/Deposit.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { Writer, Keys, Schemas, Blocks, Block, Writers } from "../Blocks.sol";
+
+string constant NAME = "deposit";
+
+using Blocks for Block;
+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, Schemas.Amount, depositId, Channels.Setup, Channels.Balances);
+    }
+
+    /// @dev Override to receive externally sourced funds for `account`.
+    /// Called once per AMOUNT block and followed by a matching BALANCE output.
+    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, Keys.Amount);
+
+        while (q < next) {
+            Block memory ref = Blocks.from(c.request, q);
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount();
+            deposit(c.account, asset, meta, amount);
+            writer.appendBalance(asset, meta, amount);
+            q = ref.cursor;
+        }
+
+        return writer.done();
+    }
+}

package/contracts/commands/Liquidate.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandContext, CommandBase, Channels} from "./Base.sol";
+import {AssetAmount, HostAmount, Blocks, Block, Writers, Writer, Keys} from "../Blocks.sol";
+
+string constant LFBTB = "liquidateFromBalanceToBalances";
+string constant LFCTB = "liquidateFromCustodyToBalances";
+
+using Blocks for Block;
+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, Channels.Balances, Channels.Balances);
+    }
+
+    /// @dev Override to liquidate using a balance repayment amount.
+    /// `rawRoute` is zero-initialized and should be ignored when
+    /// `maybeRoute` is empty. Implementations may append returned balances to
+    /// `out`.
+    function liquidateFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block 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, Keys.Balance, outScale);
+
+        while (i < end) {
+            Block memory route;
+            if (useRoute) {
+                route = Blocks.routeFrom(c.request, q);
+                q = route.cursor;
+            }
+            Block memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue();
+            liquidateFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.cursor;
+        }
+
+        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, Channels.Custodies, Channels.Balances);
+    }
+
+    /// @dev Override to liquidate using a custody repayment amount.
+    /// `rawRoute` is zero-initialized and should be ignored when
+    /// `maybeRoute` is empty. Implementations may append returned balances to
+    /// `out`.
+    function liquidateFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        Block 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, Keys.Custody, outScale);
+
+        while (i < end) {
+            Block memory route;
+            if (useRoute) {
+                route = Blocks.routeFrom(c.request, q);
+                q = route.cursor;
+            }
+            Block memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue();
+            liquidateFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.cursor;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Liquidity.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { AssetAmount, HostAmount, Keys, Schemas, Blocks, Block, BlockPair, Writers, Writer } from "../Blocks.sol";
+
+using Blocks for Block;
+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 = Schemas.route1(maybeRoute, Schemas.Minimum);
+        emit Command(host, ALFCTB, schema, addLiquidityFromCustodiesToBalancesId, Channels.Custodies, Channels.Balances);
+    }
+
+    /// @dev Override to add liquidity from two custody inputs.
+    /// Implementations extract the requested minimum liquidity output from
+    /// `rawRoute.innerMinimum()` and may append up to three BALANCE blocks to
+    /// `out`: two refunds plus the liquidity receipt.
+    function addLiquidityFromCustodiesToBalances(
+        bytes32 account,
+        BlockPair memory rawCustodies,
+        Block 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, Keys.Custody, outScale);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            BlockPair memory custodies;
+            custodies = Blocks.twoFrom(c.state, i);
+            i = custodies.b.cursor;
+            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 = Schemas.route2(maybeRoute, Schemas.Minimum, Schemas.Minimum);
+        emit Command(host, RLFCTB, schema, removeLiquidityFromCustodyToBalancesId, Channels.Custodies, Channels.Balances);
+    }
+
+    /// @dev Override to remove liquidity from a custody position.
+    /// Implementations extract requested minimum outputs from `rawRoute` and
+    /// may append up to two BALANCE blocks to `out`.
+    function removeLiquidityFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        Block 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, Keys.Custody, outScale);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            Block memory ref = Blocks.from(c.state, i);
+            HostAmount memory custody = ref.toCustodyValue();
+            removeLiquidityFromCustodyToBalances(c.account, custody, route, writer);
+            i = ref.cursor;
+        }
+
+        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 = Schemas.route1(maybeRoute, Schemas.Minimum);
+        emit Command(host, ALFBTB, schema, addLiquidityFromBalancesToBalancesId, Channels.Balances, Channels.Balances);
+    }
+
+    /// @dev Override to add liquidity from two balance inputs.
+    /// Implementations extract the requested minimum liquidity output from
+    /// `rawRoute.innerMinimum()` and may append up to three BALANCE blocks to
+    /// `out`: two refunds plus the liquidity receipt.
+    function addLiquidityFromBalancesToBalances(
+        bytes32 account,
+        BlockPair memory rawBalances,
+        Block 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, Keys.Balance, outScale);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            BlockPair memory balances;
+            balances = Blocks.twoFrom(c.state, i);
+            i = balances.b.cursor;
+            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 = Schemas.route2(maybeRoute, Schemas.Minimum, Schemas.Minimum);
+        emit Command(host, RLFBTB, schema, removeLiquidityFromBalanceToBalancesId, Channels.Balances, Channels.Balances);
+    }
+
+    /// @dev Override to remove liquidity from a balance position.
+    /// Implementations extract requested minimum outputs from `rawRoute` and
+    /// may append up to two BALANCE blocks to `out`.
+    function removeLiquidityFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block 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, Keys.Balance, outScale);
+
+        while (i < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            Block memory ref = Blocks.from(c.state, i);
+            AssetAmount memory balance = ref.toBalanceValue();
+            removeLiquidityFromBalanceToBalances(c.account, balance, route, writer);
+            i = ref.cursor;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Mint.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandBase, CommandContext, Channels } from "./Base.sol";
+import { Blocks, Block, Writers, Writer, Keys } 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, Channels.Setup, Channels.Balances);
+    }
+
+    /// @dev Override to mint balances described by `rawRoute` for `account`.
+    /// Implementations may append one or more BALANCE blocks to `out`.
+    function mintToBalances(
+        bytes32 account,
+        Block 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, Keys.Route, outScale);
+
+        while (q < end) {
+            Block memory route;
+            route = Blocks.routeFrom(c.request, q);
+            q = route.cursor;
+            mintToBalances(c.account, route, writer);
+        }
+
+        return writer.finish();
+    }
+}