@fastish/contracts 0.1.0

package/contracts/peer/Pull.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {Data, DataRef, ROUTE_KEY} from "../Blocks.sol";
+using Data for DataRef;
+
+string constant NAME = "peerPull";
+
+abstract contract PeerPull is PeerBase {
+    uint internal immutable peerPullId = peerId(NAME);
+
+    constructor(string memory route) {
+        emit Peer(host, NAME, route, peerPullId);
+    }
+
+    function peerPull(DataRef memory rawRoute) internal virtual;
+
+    function peerPull(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            (DataRef memory ref, uint next) = Data.from(request, q);
+            if (ref.key != ROUTE_KEY) break;
+            peerPull(ref);
+            q = next;
+        }
+
+        return done(0, q);
+    }
+}

package/contracts/peer/Push.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {Data, DataRef, ROUTE_KEY} from "../Blocks.sol";
+using Data for DataRef;
+
+string constant NAME = "peerPush";
+
+abstract contract PeerPush is PeerBase {
+    uint internal immutable peerPushId = peerId(NAME);
+
+    constructor(string memory route) {
+        emit Peer(host, NAME, route, peerPushId);
+    }
+
+    function peerPush(DataRef memory rawRoute) internal virtual;
+
+    function peerPush(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            (DataRef memory ref, uint next) = Data.from(request, q);
+            if (ref.key != ROUTE_KEY) break;
+            peerPush(ref);
+            q = next;
+        }
+
+        return done(0, q);
+    }
+}

package/contracts/test/TestBlockHelper.sol

@@ -0,0 +1,256 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AssetAmount, HostAmount, Tx, BlockRef, DataRef, MemRef, Writer, BALANCE_KEY, CUSTODY_KEY, TX_KEY, AMOUNT_KEY, BOUNTY_KEY, RECIPIENT_KEY, NODE_KEY, FUNDING_KEY, ASSET_KEY, ALLOCATION_KEY, STEP_KEY, QUANTITY_KEY} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+import {Data} from "../blocks/Data.sol";
+import {Mem} from "../blocks/Mem.sol";
+import {InvalidBlock, MalformedBlocks, UnexpectedAsset, UnexpectedHost, UnexpectedMeta, ZeroRecipient, ZeroNode} from "../blocks/Errors.sol";
+import {Writers, BALANCE_BLOCK_LEN, CUSTODY_BLOCK_LEN, TX_BLOCK_LEN} from "../blocks/Writers.sol";
+
+using Blocks for BlockRef;
+using Data for DataRef;
+using Writers for Writer;
+using Mem for MemRef;
+
+contract TestBlockHelper {
+    // ── Writers ──────────────────────────────────────────────────────────────
+
+    function testBlockHeader(bytes4 key, uint selfLen, uint totalLen) external pure returns (uint) {
+        return Writers.toBlockHeader(key, selfLen, totalLen);
+    }
+
+    function testWriteBalanceBlock(bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(BALANCE_BLOCK_LEN);
+        w.appendBalance(asset, meta, amount);
+        return w.dst;
+    }
+
+    function testWriteTwoBalanceBlocks(
+        bytes32 a1, bytes32 m1, uint v1,
+        bytes32 a2, bytes32 m2, uint v2
+    ) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(BALANCE_BLOCK_LEN * 2);
+        w.appendBalance(a1, m1, v1);
+        w.appendBalance(a2, m2, v2);
+        return w.dst;
+    }
+
+    function testWriteCustodyBlock(uint host_, bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(CUSTODY_BLOCK_LEN);
+        w.appendCustody(host_, asset, meta, amount);
+        return w.dst;
+    }
+
+    function testWriteTxBlock(bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(TX_BLOCK_LEN);
+        w.appendTx(Tx({from: from_, to: to_, asset: asset, meta: meta, amount: amount}));
+        return w.dst;
+    }
+
+    function testWriterDone() external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(BALANCE_BLOCK_LEN);
+        // Don't write anything — done() should revert
+        return Writers.done(w);
+    }
+
+    function testWriterFinish(bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(BALANCE_BLOCK_LEN * 2);
+        w.appendBalance(asset, meta, amount);
+        return Writers.finish(w);
+    }
+
+    // ── Blocks (calldata) ────────────────────────────────────────────────────
+
+    function testParseBlock(bytes calldata source, uint i)
+        external pure returns (bytes4 key, uint bound, uint end)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        return (ref.key, ref.bound, ref.end);
+    }
+
+    function testUnpackAmount(bytes calldata source, uint i)
+        external pure returns (bytes32 asset, bytes32 meta, uint amount)
+    {
+        BlockRef memory ref = Blocks.amountFrom(source, i);
+        return ref.unpackAmount(source);
+    }
+
+    function testUnpackBalance(bytes calldata source, uint i)
+        external pure returns (bytes32 asset, bytes32 meta, uint amount)
+    {
+        BlockRef memory ref = Blocks.balanceFrom(source, i);
+        return ref.unpackBalance(source);
+    }
+
+    function testUnpackCustody(bytes calldata source, uint i)
+        external pure returns (uint host_, bytes32 asset, bytes32 meta, uint amount)
+    {
+        BlockRef memory ref = Blocks.custodyFrom(source, i);
+        HostAmount memory v = ref.toCustodyValue(source);
+        return (v.host, v.asset, v.meta, v.amount);
+    }
+
+    function testUnpackRecipient(bytes calldata source, uint i)
+        external pure returns (bytes32 account)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        return ref.unpackRecipient(source);
+    }
+
+    function testUnpackNode(bytes calldata source, uint i)
+        external pure returns (uint id)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        return ref.unpackNode(source);
+    }
+
+    function testUnpackQuantity(bytes calldata source, uint i)
+        external pure returns (uint amount)
+    {
+        BlockRef memory ref = Blocks.quantityFrom(source, i);
+        return ref.unpackQuantity(source);
+    }
+
+    function testExpectMinimum(bytes calldata source, uint i, bytes32 asset, bytes32 meta)
+        external pure returns (uint amount)
+    {
+        (DataRef memory ref, ) = Data.from(source, i);
+        return ref.expectMinimum(asset, meta);
+    }
+
+    function testExpectAmount(bytes calldata source, uint i, bytes32 asset, bytes32 meta)
+        external pure returns (uint amount)
+    {
+        (DataRef memory ref, ) = Data.from(source, i);
+        return ref.expectAmount(asset, meta);
+    }
+
+    function testExpectBalance(bytes calldata source, uint i, bytes32 asset, bytes32 meta)
+        external pure returns (uint amount)
+    {
+        (DataRef memory ref, ) = Data.from(source, i);
+        return ref.expectBalance(asset, meta);
+    }
+
+    function testExpectMaximum(bytes calldata source, uint i, bytes32 asset, bytes32 meta)
+        external pure returns (uint amount)
+    {
+        (DataRef memory ref, ) = Data.from(source, i);
+        return ref.expectMaximum(asset, meta);
+    }
+
+    function testExpectCustody(bytes calldata source, uint i, uint host_)
+        external pure returns (bytes32 asset, bytes32 meta, uint amount)
+    {
+        (DataRef memory ref, ) = Data.from(source, i);
+        AssetAmount memory value = ref.expectCustody(host_);
+        return (value.asset, value.meta, value.amount);
+    }
+
+    function testUnpackFunding(bytes calldata source, uint i)
+        external pure returns (uint host_, uint amount)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        return ref.unpackFunding(source);
+    }
+
+    function testUnpackAsset(bytes calldata source, uint i)
+        external pure returns (bytes32 asset, bytes32 meta)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        return ref.unpackAsset(source);
+    }
+
+    function testUnpackAllocation(bytes calldata source, uint i)
+        external pure returns (uint host_, bytes32 asset, bytes32 meta, uint amount)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        HostAmount memory v = ref.toAllocationValue(source);
+        return (v.host, v.asset, v.meta, v.amount);
+    }
+
+    function testToTxValue(bytes calldata source, uint i)
+        external pure returns (bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount)
+    {
+        BlockRef memory ref = Blocks.from(source, i);
+        Tx memory t = ref.toTxValue(source);
+        return (t.from, t.to, t.asset, t.meta, t.amount);
+    }
+
+    function testCountBlocks(bytes calldata source, uint i, bytes4 key)
+        external pure returns (uint count, uint next)
+    {
+        return Blocks.count(source, i, key);
+    }
+
+    function testResolveRecipient(bytes calldata source, uint i, uint limit, bytes32 backup)
+        external pure returns (bytes32)
+    {
+        return Blocks.resolveRecipient(source, i, limit, backup);
+    }
+
+    function testResolveNode(bytes calldata source, uint i, uint limit, uint backup)
+        external pure returns (uint)
+    {
+        return Blocks.resolveNode(source, i, limit, backup);
+    }
+
+    function testCreate32(bytes4 key, bytes32 value) external pure returns (bytes memory) {
+        return Blocks.create32(key, value);
+    }
+
+    function testCreate64(bytes4 key, bytes32 a, bytes32 b) external pure returns (bytes memory) {
+        return Blocks.create64(key, a, b);
+    }
+
+    function testCreate96(bytes4 key, bytes32 a, bytes32 b, bytes32 c) external pure returns (bytes memory) {
+        return Blocks.create96(key, a, b, c);
+    }
+
+    function testCreate128(bytes4 key, bytes32 a, bytes32 b, bytes32 c, bytes32 d) external pure returns (bytes memory) {
+        return Blocks.create128(key, a, b, c, d);
+    }
+
+    function testToBounty(uint amount, bytes32 relayer) external pure returns (bytes memory) {
+        return Blocks.toBountyBlock(amount, relayer);
+    }
+
+    function testToCustody(uint host_, bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        return Blocks.toCustodyBlock(host_, asset, meta, amount);
+    }
+
+    // ── Mem (memory) ─────────────────────────────────────────────────────────
+
+    function testMemParseBalance(bytes memory source, uint i)
+        external pure returns (bytes32 asset, bytes32 meta, uint amount)
+    {
+        MemRef memory ref = Mem.from(source, i);
+        return ref.unpackBalance(source);
+    }
+
+    function testMemParseCustody(bytes memory source, uint i)
+        external pure returns (HostAmount memory value)
+    {
+        MemRef memory ref = Mem.from(source, i);
+        return ref.toCustodyValue(source);
+    }
+
+    function testMemSlice(bytes memory source, uint start, uint end_)
+        external pure returns (bytes memory)
+    {
+        return Mem.slice(source, start, end_);
+    }
+
+    function testMemCount(bytes memory source, uint i, bytes4 key)
+        external pure returns (uint count, uint next)
+    {
+        return Mem.count(source, i, key);
+    }
+
+    function testAllocBalancesFromCount(bytes calldata source, uint i, bytes4 sourceKey)
+        external pure returns (uint count, uint next)
+    {
+        return Blocks.count(source, i, sourceKey);
+    }
+}

package/contracts/test/TestBorrowHost.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Host} from "../core/Host.sol";
+import {BorrowAgainstCustodyToBalance} from "../commands/Borrow.sol";
+import {AssetAmount, HostAmount, DataRef} from "../blocks/Schema.sol";
+import {Data} from "../blocks/Data.sol";
+import {toHostId} from "../utils/Ids.sol";
+
+using Data for DataRef;
+
+contract TestBorrowHost is Host, BorrowAgainstCustodyToBalance {
+    event BorrowCalled(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") BorrowAgainstCustodyToBalance("") {
+        if (cmdr != address(0)) access(toHostId(cmdr), true);
+    }
+
+    function setReturn(bytes32 asset, bytes32 meta, uint amount) external {
+        returnAsset = asset;
+        returnMeta = meta;
+        returnAmount = amount;
+    }
+
+    function borrowAgainstCustodyToBalance(
+        bytes32 account,
+        HostAmount memory custody,
+        DataRef memory rawRoute
+    ) internal override returns (AssetAmount memory) {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit BorrowCalled(account, custody.asset, custody.meta, custody.amount, routeData);
+        return AssetAmount({asset: returnAsset, meta: returnMeta, amount: returnAmount});
+    }
+
+    function getBorrowId() external view returns (uint) {
+        return borrowAgainstCustodyToBalanceId;
+    }
+
+    function getAdminAccount() external view returns (bytes32) {
+        return adminAccount;
+    }
+}

package/contracts/test/TestBurnHost.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Host} from "../core/Host.sol";
+import {Burn} from "../commands/Burn.sol";
+import {toHostId} from "../utils/Ids.sol";
+
+contract TestBurnHost is Host, Burn {
+    event BurnCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        Burn("")
+    {
+        if (cmdr != address(0)) access(toHostId(cmdr), true);
+    }
+
+    function burn(bytes32 account, bytes32 asset, bytes32 meta, uint amount)
+        internal override
+        returns (uint)
+    {
+        emit BurnCalled(account, asset, meta, amount);
+        return amount;
+    }
+
+    function getBurnId() external view returns (uint) { return burnId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}

package/contracts/test/TestCreateHost.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Host} from "../core/Host.sol";
+import {Create} from "../commands/Create.sol";
+import {DataRef} from "../blocks/Schema.sol";
+import {toHostId} from "../utils/Ids.sol";
+
+contract TestCreateHost is Host, Create {
+    event CreateCalled(bytes32 account, bytes routeData);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        Create("")
+    {
+        if (cmdr != address(0)) access(toHostId(cmdr), true);
+    }
+
+    function create(bytes32 account, DataRef memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit CreateCalled(account, routeData);
+    }
+
+    function getCreateId() external view returns (uint) { return createId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}

package/contracts/test/TestDiscovery.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {HostDiscovery} from "../core/Host.sol";
+
+contract TestDiscovery is HostDiscovery {}

package/contracts/test/TestECDSA.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {ECDSA} from "../utils/ECDSA.sol";
+
+contract TestECDSA {
+    using ECDSA for bytes32;
+
+    function testToEthSignedMessageHash(bytes32 hash) external pure returns (bytes32) {
+        return hash.toEthSignedMessageHash();
+    }
+
+    function testTryRecoverCalldata(bytes32 hash, bytes calldata signature) external pure returns (address) {
+        return hash.tryRecoverCalldata(signature);
+    }
+}

package/contracts/test/TestHost.sol

@@ -0,0 +1,215 @@
+// 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 {CreditBalanceToAccount} from "../commands/CreditTo.sol";
+import {DebitAccountToBalance} from "../commands/DebitFrom.sol";
+import {Settle} from "../commands/Settle.sol";
+import {Fund} from "../commands/Fund.sol";
+import {Provision} 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 {DataRef, Tx, Writer} from "../blocks/Schema.sol";
+import {Writers} from "../blocks/Writers.sol";
+
+using Writers for Writer;
+
+contract TestHost is
+    Host,
+    Deposit,
+    Withdraw,
+    Transfer,
+    CreditBalanceToAccount,
+    DebitAccountToBalance,
+    Settle,
+    Fund,
+    Provision,
+    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 FundCalled(uint host_, bytes32 account, 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 fastish) Host(fastish, 1, "test") Deposit() Provision(10_000) 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 fund(uint host_, bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal override {
+        emit FundCalled(host_, account, asset, meta, amount);
+    }
+
+    function provision(
+        bytes32 account,
+        uint host_,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount,
+        Writer memory out
+    ) internal override {
+        emit ProvisionCalled(host_, account, asset, meta, amount);
+        out.appendCustody(host_, asset, meta, amount);
+    }
+
+    function init(DataRef memory rawRoute) internal override {
+        bytes calldata routeData = msg.data[rawRoute.i:rawRoute.bound];
+        emit InitCalled(routeData);
+    }
+
+    function destroy(DataRef 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 getCreditBalanceToAccountId() external view returns (uint) {
+        return creditBalanceToAccountId;
+    }
+
+    function getDebitAccountToBalanceId() external view returns (uint) {
+        return debitAccountToBalanceId;
+    }
+
+    function getSettleId() external view returns (uint) {
+        return settleId;
+    }
+
+    function getFundId() external view returns (uint) {
+        return fundId;
+    }
+
+    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];
+    }
+}