@rootzero/contracts 0.2.0

package/contracts/test/TestHost.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { Deposit } from "../commands/Deposit.sol";
+import { Withdraw } from "../commands/Withdraw.sol";
+import { Transfer } from "../commands/Transfer.sol";
+import { CreditAccount } from "../commands/Credit.sol";
+import { DebitAccount } from "../commands/Debit.sol";
+import { Settle } from "../commands/Settle.sol";
+import { Provision, ProvisionFromBalance } from "../commands/Provision.sol";
+import { Pipe } from "../commands/Pipe.sol";
+import { AllowAssets } from "../commands/admin/AllowAssets.sol";
+import { DenyAssets } from "../commands/admin/DenyAssets.sol";
+import { Destroy } from "../commands/admin/Destroy.sol";
+import { Init } from "../commands/admin/Init.sol";
+import { Allocate } from "../commands/admin/Allocate.sol";
+import { Tx } from "../blocks/Schema.sol";
+import { Block } from "../Blocks.sol";
+
+contract TestHost is
+    Host,
+    Deposit,
+    Withdraw,
+    Transfer,
+    CreditAccount,
+    DebitAccount,
+    Settle,
+    Provision,
+    ProvisionFromBalance,
+    Pipe,
+    Init,
+    Destroy,
+    AllowAssets,
+    DenyAssets,
+    Allocate
+{
+    event DepositCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount);
+    event WithdrawCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount);
+    event TransferCalled(bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount);
+    event CreditToCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount, uint returned);
+    event DebitFromCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount, uint returned);
+    event SettleCalled(bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount);
+    event ProvisionCalled(uint host_, bytes32 account, bytes32 asset, bytes32 meta, uint amount);
+    event InitCalled(bytes routeData);
+    event DestroyCalled(bytes routeData);
+    event AllowAssetCalled(bytes32 asset, bytes32 meta);
+    event DenyAssetCalled(bytes32 asset, bytes32 meta);
+    event AllocateCalled(uint host_, bytes32 asset, bytes32 meta, uint amount);
+    event StepDispatched(uint target, uint stepIndex, uint value);
+
+    uint public stepCount;
+
+    constructor(address rootzero) Host(rootzero, 1, "test") Deposit() Provision() Init("") Destroy("") {}
+
+    function deposit(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit DepositCalled(account, asset, meta, amount);
+    }
+
+    function withdraw(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit WithdrawCalled(account, asset, meta, amount);
+    }
+
+    function transfer(bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit TransferCalled(from_, to_, asset, meta, amount);
+    }
+
+    function creditAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit CreditToCalled(account, asset, meta, amount, amount);
+    }
+
+    function debitAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit DebitFromCalled(account, asset, meta, amount, amount);
+    }
+
+    function settle(Tx memory value) internal override {
+        emit SettleCalled(value.from, value.to, value.asset, value.meta, value.amount);
+    }
+
+    function provision(bytes32 account, uint host_, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit ProvisionCalled(host_, account, asset, meta, amount);
+    }
+
+    function init(Block memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit InitCalled(routeData);
+    }
+
+    function destroy(Block memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit DestroyCalled(routeData);
+    }
+
+    function allowAsset(bytes32 asset, bytes32 meta) internal override returns (bool) {
+        emit AllowAssetCalled(asset, meta);
+        return true;
+    }
+
+    function denyAsset(bytes32 asset, bytes32 meta) internal override returns (bool) {
+        emit DenyAssetCalled(asset, meta);
+        return true;
+    }
+
+    function allocate(uint host_, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit AllocateCalled(host_, asset, meta, amount);
+    }
+
+    function dispatchStep(
+        uint target,
+        bytes32,
+        bytes memory state,
+        bytes calldata,
+        uint value
+    ) internal override returns (bytes memory) {
+        emit StepDispatched(target, stepCount++, value);
+        return state;
+    }
+
+    // Expose internal host/admin IDs for tests
+    function getDepositId() external view returns (uint) {
+        return depositId;
+    }
+
+    function getWithdrawId() external view returns (uint) {
+        return withdrawId;
+    }
+
+    function getTransferId() external view returns (uint) {
+        return transferId;
+    }
+
+    function getCreditAccountId() external view returns (uint) {
+        return creditAccountId;
+    }
+
+    function getDebitAccountId() external view returns (uint) {
+        return debitAccountId;
+    }
+
+    function getSettleId() external view returns (uint) {
+        return settleId;
+    }
+
+    function getProvisionFromBalanceId() external view returns (uint) {
+        return provisionFromBalanceId;
+    }
+
+    function getProvisionId() external view returns (uint) {
+        return provisionId;
+    }
+
+    function getPipeId() external view returns (uint) {
+        return pipeId;
+    }
+
+    function getInitId() external view returns (uint) {
+        return initId;
+    }
+
+    function getDestroyId() external view returns (uint) {
+        return destroyId;
+    }
+
+    function getAuthorizeId() external view returns (uint) {
+        return authorizeId;
+    }
+
+    function getUnauthorizeId() external view returns (uint) {
+        return unauthorizeId;
+    }
+
+    function getRelocateId() external view returns (uint) {
+        return relocateId;
+    }
+
+    function getAllowAssetsId() external view returns (uint) {
+        return allowAssetsId;
+    }
+
+    function getDenyAssetsId() external view returns (uint) {
+        return denyAssetsId;
+    }
+
+    function getAllocateId() external view returns (uint) {
+        return allocateId;
+    }
+
+    function getAdminAccount() external view returns (bytes32) {
+        return adminAccount;
+    }
+
+    function getCommander() external view returns (address) {
+        return commander;
+    }
+
+    function isAuthorized(uint node) external view returns (bool) {
+        return authorized[node];
+    }
+}

package/contracts/test/TestLiquidityHost.sol

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { AddLiquidityFromCustodiesToBalances, RemoveLiquidityFromCustodyToBalances, AddLiquidityFromBalancesToBalances, RemoveLiquidityFromBalanceToBalances } from "../commands/Liquidity.sol";
+import { Blocks } from "../blocks/Blocks.sol";
+import { AssetAmount, HostAmount } from "../blocks/Schema.sol";
+import { Block, BlockPair, Writer } from "../Blocks.sol";
+import { Writers } from "../blocks/Writers.sol";
+import { Ids } from "../utils/Ids.sol";
+
+using Blocks for Block;
+using Writers for Writer;
+
+contract TestLiquidityHost is
+    Host,
+    AddLiquidityFromCustodiesToBalances,
+    RemoveLiquidityFromCustodyToBalances,
+    AddLiquidityFromBalancesToBalances,
+    RemoveLiquidityFromBalanceToBalances
+{
+    bytes32 internal constant LP_FROM_CUSTODIES_ASSET = bytes32(uint(0xaaa1));
+    bytes32 internal constant LP_FROM_BALANCES_ASSET = bytes32(uint(0xaaa2));
+    bytes32 internal constant REDEEM_FROM_CUSTODY_ASSET = bytes32(uint(0xbbb1));
+    bytes32 internal constant REDEEM_FROM_BALANCE_ASSET = bytes32(uint(0xbbb2));
+
+    event AddCustodiesMapped(
+        bytes32 account,
+        bytes32 assetA,
+        uint amountA,
+        bytes32 assetB,
+        uint amountB,
+        bytes routeData
+    );
+    event RemoveCustodyMapped(bytes32 account, bytes32 asset, uint amount, bytes routeData);
+    event AddBalancesMapped(
+        bytes32 account,
+        bytes32 assetA,
+        uint amountA,
+        bytes32 assetB,
+        uint amountB,
+        bytes routeData
+    );
+    event RemoveBalanceMapped(bytes32 account, bytes32 asset, uint amount, bytes routeData);
+    event MinimumObserved(bytes32 asset, bytes32 meta, uint amount);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        AddLiquidityFromCustodiesToBalances("route(bytes data)", 15_000)
+        RemoveLiquidityFromCustodyToBalances("route(bytes data)", 20_000)
+        AddLiquidityFromBalancesToBalances("route(bytes data)", 15_000)
+        RemoveLiquidityFromBalanceToBalances("route(bytes data)", 20_000)
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function addLiquidityFromCustodiesToBalances(
+        bytes32 account,
+        BlockPair memory rawCustodies,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal override {
+        HostAmount memory a = rawCustodies.a.toCustodyValue();
+        HostAmount memory b = rawCustodies.b.toCustodyValue();
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        uint routeLen = rawRoute.bound - rawRoute.i;
+        emit AddCustodiesMapped(account, a.asset, a.amount, b.asset, b.amount, routeData);
+        emitMinimum(rawRoute);
+
+        out.appendBalance(a.asset, a.meta, a.amount + routeLen);
+        out.appendBalance(b.asset, b.meta, b.amount + routeLen + 1);
+        out.appendBalance(LP_FROM_CUSTODIES_ASSET, bytes32(routeLen), a.amount + b.amount);
+    }
+
+    function removeLiquidityFromCustodyToBalances(
+        bytes32 account,
+        HostAmount memory custody,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        uint routeLen = rawRoute.bound - rawRoute.i;
+        emit RemoveCustodyMapped(account, custody.asset, custody.amount, routeData);
+        emitMinimum(rawRoute);
+
+        out.appendBalance(custody.asset, custody.meta, custody.amount + routeLen);
+        out.appendBalance(REDEEM_FROM_CUSTODY_ASSET, bytes32(routeLen), custody.amount + 10);
+    }
+
+    function addLiquidityFromBalancesToBalances(
+        bytes32 account,
+        BlockPair memory rawBalances,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal override {
+        AssetAmount memory a = rawBalances.a.toBalanceValue();
+        AssetAmount memory b = rawBalances.b.toBalanceValue();
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        uint routeLen = rawRoute.bound - rawRoute.i;
+        emit AddBalancesMapped(account, a.asset, a.amount, b.asset, b.amount, routeData);
+        emitMinimum(rawRoute);
+
+        out.appendBalance(a.asset, a.meta, a.amount + routeLen);
+        out.appendBalance(b.asset, b.meta, b.amount + routeLen + 2);
+        out.appendBalance(LP_FROM_BALANCES_ASSET, bytes32(routeLen), a.amount + b.amount);
+    }
+
+    function removeLiquidityFromBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        uint routeLen = rawRoute.bound - rawRoute.i;
+        emit RemoveBalanceMapped(account, balance.asset, balance.amount, routeData);
+        emitMinimum(rawRoute);
+
+        out.appendBalance(balance.asset, balance.meta, balance.amount + routeLen);
+        out.appendBalance(REDEEM_FROM_BALANCE_ASSET, bytes32(routeLen), balance.amount + 20);
+    }
+
+    function emitMinimum(Block memory rawRoute) internal {
+        if (rawRoute.bound < rawRoute.end) {
+            (bytes32 asset, bytes32 meta, uint amount) = rawRoute.innerMinimum();
+            emit MinimumObserved(asset, meta, amount);
+        }
+    }
+
+    function getAddLiquidityFromCustodiesToBalancesId() external view returns (uint) {
+        return addLiquidityFromCustodiesToBalancesId;
+    }
+
+    function getRemoveLiquidityFromCustodyToBalancesId() external view returns (uint) {
+        return removeLiquidityFromCustodyToBalancesId;
+    }
+
+    function getAddLiquidityFromBalancesToBalancesId() external view returns (uint) {
+        return addLiquidityFromBalancesToBalancesId;
+    }
+
+    function getRemoveLiquidityFromBalanceToBalancesId() external view returns (uint) {
+        return removeLiquidityFromBalanceToBalancesId;
+    }
+}

package/contracts/test/TestMintHost.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { MintToBalances } from "../commands/Mint.sol";
+import { Block, Writer } from "../Blocks.sol";
+import { Writers } from "../blocks/Writers.sol";
+import { Ids } from "../utils/Ids.sol";
+
+using Writers for Writer;
+
+contract TestMintHost is Host, MintToBalances {
+    event MintCalled(bytes32 account, bytes routeData);
+
+    bytes32 public returnAsset;
+    bytes32 public returnMeta;
+    uint    public returnAmount;
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        MintToBalances("", 10_000)
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function setReturn(bytes32 asset, bytes32 meta, uint amount) external {
+        returnAsset = asset;
+        returnMeta  = meta;
+        returnAmount = amount;
+    }
+
+    function mintToBalances(bytes32 account, Block memory rawRoute, Writer memory out) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit MintCalled(account, routeData);
+        if (returnAmount > 0) out.appendBalance(returnAsset, returnMeta, returnAmount);
+    }
+
+    function getMintId() external view returns (uint) { return mintToBalancesId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}

package/contracts/test/TestPeerHost.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { PeerPull } from "../peer/Pull.sol";
+import { PeerPush } from "../peer/Push.sol";
+import { Block } from "../Blocks.sol";
+import { Ids } from "../utils/Ids.sol";
+
+contract TestPeerHost is Host, PeerPull, PeerPush {
+    event PeerPullCalled(bytes routeData);
+    event PeerPushCalled(bytes routeData);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        PeerPull("")
+        PeerPush("")
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function peerPull(Block memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit PeerPullCalled(routeData);
+    }
+
+    function peerPush(Block memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit PeerPushCalled(routeData);
+    }
+
+    function getPeerPullId() external view returns (uint) { return peerPullId; }
+    function getPeerPushId() external view returns (uint) { return peerPushId; }
+}

package/contracts/test/TestReclaimHost.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { ReclaimToBalances } from "../commands/Reclaim.sol";
+import { AssetAmount } from "../blocks/Schema.sol";
+import { Block, Writer } from "../Blocks.sol";
+import { Blocks } from "../blocks/Blocks.sol";
+import { Writers } from "../blocks/Writers.sol";
+import { Ids } from "../utils/Ids.sol";
+
+using Blocks for Block;
+using Writers for Writer;
+
+contract TestReclaimHost is Host, ReclaimToBalances {
+    event ReclaimCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount, bytes routeData);
+
+    bytes32 public returnAsset;
+    bytes32 public returnMeta;
+    uint    public returnAmount;
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        ReclaimToBalances("", 10_000)
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function setReturn(bytes32 asset, bytes32 meta, uint amount) external {
+        returnAsset = asset;
+        returnMeta  = meta;
+        returnAmount = amount;
+    }
+
+    function reclaimToBalances(
+        bytes32 account,
+        AssetAmount memory amount,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit ReclaimCalled(account, amount.asset, amount.meta, amount.amount, routeData);
+        if (returnAmount > 0) out.appendBalance(returnAsset, returnMeta, returnAmount);
+    }
+
+    function getReclaimBalanceId() external view returns (uint) { return reclaimToBalancesId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}

package/contracts/test/TestRejectEther.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+contract TestRejectEther {
+    receive() external payable {
+        revert("NO_ETH");
+    }
+}

package/contracts/test/TestRemoveHost.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { Remove } from "../commands/Remove.sol";
+import { Block } from "../Blocks.sol";
+import { Ids } from "../utils/Ids.sol";
+
+contract TestRemoveHost is Host, Remove {
+    event RemoveCalled(bytes32 account, bytes routeData);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        Remove("")
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function remove(bytes32 account, Block memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit RemoveCalled(account, routeData);
+    }
+
+    function getRemoveId() external view returns (uint) { return removeId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}

package/contracts/test/TestSwapHost.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { SwapExactBalanceToBalance } from "../commands/Swap.sol";
+import { AssetAmount, Block, Blocks } from "../Blocks.sol";
+
+using Blocks for Block;
+
+contract TestSwapHost is Host, SwapExactBalanceToBalance {
+    event SwapMapped(bytes32 account, bytes32 asset, bytes32 meta, uint amount, bytes routeData);
+    event SwapMinimum(bytes32 asset, bytes32 meta, uint amount);
+
+    constructor(address rootzero)
+        Host(rootzero, 1, "test")
+        SwapExactBalanceToBalance("route(bytes data)")
+    {}
+
+    function swapExactBalanceToBalance(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block memory rawRoute
+    ) internal override returns (AssetAmount memory out) {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit SwapMapped(account, balance.asset, balance.meta, balance.amount, routeData);
+        if (rawRoute.bound < rawRoute.end) {
+            (bytes32 minAsset, bytes32 minMeta, uint minAmount) = rawRoute.innerMinimum();
+            emit SwapMinimum(minAsset, minMeta, minAmount);
+        }
+        return AssetAmount({
+            asset: balance.asset,
+            meta: bytes32(rawRoute.bound - rawRoute.i),
+            amount: balance.amount + (rawRoute.bound - rawRoute.i)
+        });
+    }
+
+    function getSwapExactInAsset32Id() external view returns (uint) {
+        return swapExactBalanceToBalanceId;
+    }
+
+    function getAdminAccount() external view returns (bytes32) {
+        return adminAccount;
+    }
+}