@fastish/contracts 0.1.0

package/contracts/commands/admin/Authorize.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {BlockRef, NODE, NODE_KEY} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "authorize";
+
+abstract contract Authorize is CommandBase {
+    uint internal immutable authorizeId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, NODE, authorizeId, SETUP, SETUP);
+    }
+
+    function authorize(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(authorizeId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != NODE_KEY) break;
+            uint node = ref.unpackNode(c.request);
+            access(node, true);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/DenyAssets.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {ASSET, ASSET_KEY, BlockRef} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "denyAssets";
+
+abstract contract DenyAssets is CommandBase {
+    uint internal immutable denyAssetsId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, ASSET, denyAssetsId, SETUP, SETUP);
+    }
+
+    function denyAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
+
+    function denyAssets(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(denyAssetsId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != ASSET_KEY) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset(c.request);
+            denyAsset(asset, meta);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Destroy.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {Data, DataRef} from "../../Blocks.sol";
+
+string constant NAME = "destroy";
+
+abstract contract Destroy is CommandBase {
+    uint internal immutable destroyId = commandId(NAME);
+
+    constructor(string memory route) {
+        emit Command(host, NAME, route, destroyId, SETUP, SETUP);
+    }
+
+    function destroy(DataRef memory rawRoute) internal virtual;
+
+    function destroy(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(destroyId, c.target) returns (bytes memory) {
+        (DataRef memory route, uint q) = Data.routeFrom(c.request, 0);
+        destroy(route);
+        return done(0, q);
+    }
+}

package/contracts/commands/admin/Init.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {Data, DataRef} from "../../Blocks.sol";
+
+string constant NAME = "init";
+
+abstract contract Init is CommandBase {
+    uint internal immutable initId = commandId(NAME);
+
+    constructor(string memory route) {
+        emit Command(host, NAME, route, initId, SETUP, SETUP);
+    }
+
+    function init(DataRef memory rawRoute) internal virtual;
+
+    function init(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(initId, c.target) returns (bytes memory) {
+        (DataRef memory route, uint q) = Data.routeFrom(c.request, 0);
+        init(route);
+        return done(0, q);
+    }
+}

package/contracts/commands/admin/Relocate.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {BlockRef, FUNDING, FUNDING_KEY} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "relocate";
+
+abstract contract Relocate is CommandBase {
+    uint internal immutable relocateId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, FUNDING, relocateId, SETUP, SETUP);
+    }
+
+    function relocate(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(relocateId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != FUNDING_KEY) break;
+            (uint host, uint amount) = ref.unpackFunding(c.request);
+            callTo(host, amount, "");
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Unauthorize.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {CommandBase, CommandContext} from "../Base.sol";
+import {SETUP} from "../../utils/Channels.sol";
+import {BlockRef, NODE, NODE_KEY} from "../../blocks/Schema.sol";
+import {Blocks} from "../../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "unauthorize";
+
+abstract contract Unauthorize is CommandBase {
+    uint internal immutable unauthorizeId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, NODE, unauthorizeId, SETUP, SETUP);
+    }
+
+    function unauthorize(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(unauthorizeId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            BlockRef memory ref = Blocks.from(c.request, i);
+            if (ref.key != NODE_KEY) break;
+            uint node = ref.unpackNode(c.request);
+            access(node, false);
+            i = ref.end;
+        }
+        return done(0, i);
+    }
+}

package/contracts/core/Access.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AccessEvent} from "../events/Access.sol";
+import {addrOr, toAdminAccount} from "../utils/Accounts.sol";
+import {toHostId} from "../utils/Ids.sol";
+
+abstract contract AccessControl is AccessEvent {
+    address internal immutable commander;
+    bytes32 internal immutable adminAccount;
+    uint public immutable host;
+
+    mapping(uint => bool) internal authorized;
+
+    error UnauthorizedNode(uint node);
+    error UnauthorizedCaller(address addr);
+
+    constructor(address cmdr) {
+        commander = addrOr(cmdr, address(this));
+        adminAccount = toAdminAccount(commander);
+        host = toHostId(address(this));
+    }
+
+    // @dev inbound auth is host-based.
+    function access(uint node, bool allow) internal {
+        authorized[node] = allow;
+        emit Access(host, node, allow);
+    }
+
+    function isTrusted(address caller) internal view returns (bool) {
+        return caller == commander || caller == address(this) || authorized[toHostId(caller)];
+    }
+
+    function enforceCaller(address caller) internal view returns (address) {
+        if (caller == address(0) || !isTrusted(caller)) {
+            revert UnauthorizedCaller(caller);
+        }
+        return caller;
+    }
+
+    // @dev Outbound trust check: accepts any authorized node id (host or COMMAND).
+    // Inbound caller auth is host-only via `enforceCaller(msg.sender)`.
+    function ensureTrusted(uint node) internal view returns (uint) {
+        if (node == 0 || !authorized[node]) {
+            revert UnauthorizedNode(node);
+        }
+        return node;
+    }
+}

package/contracts/core/Balances.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {BalanceEvent} from "../events/Balance.sol";
+
+abstract contract Balances is BalanceEvent {
+    mapping(bytes32 account => mapping(bytes32 assetRef => uint amount))
+        internal balances;
+}

package/contracts/core/Host.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AccessControl} from "./Access.sol";
+import {Authorize} from "../commands/admin/Authorize.sol";
+import {Unauthorize} from "../commands/admin/Unauthorize.sol";
+import {Relocate} from "../commands/admin/Relocate.sol";
+import {HostAnnouncedEvent} from "../events/HostAnnounced.sol";
+import {IHostDiscovery} from "../interfaces/IHostDiscovery.sol";
+import {ensureHost} from "../utils/Ids.sol";
+
+abstract contract HostDiscovery is HostAnnouncedEvent, IHostDiscovery {
+    function announceHost(uint id, uint blocknum, uint16 version, string calldata namespace) external {
+        emit HostAnnounced(ensureHost(id, msg.sender), blocknum, version, namespace);
+    }
+}
+
+abstract contract Host is Authorize, Unauthorize, Relocate {
+    constructor(address fastish, uint8 version, string memory namespace) AccessControl(fastish) {
+        if (fastish == address(0) || fastish == address(this) || fastish.code.length == 0) return;
+        IHostDiscovery(fastish).announceHost(host, block.number, version, namespace);
+    }
+
+    receive() external payable {}
+}

package/contracts/core/Operation.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AccessControl} from "./Access.sol";
+import {toValueAsset} from "../utils/Assets.sol";
+import {localNodeAddr} from "../utils/Ids.sol";
+
+error NoOperation();
+error FailedCall(address addr, uint node, bytes4 selector, bytes err);
+
+abstract contract OperationBase is AccessControl {
+    bytes32 public immutable valueAsset = toValueAsset();
+
+    function done(uint start, uint end) internal pure returns (bytes memory) {
+        if (end <= start) revert NoOperation();
+        return "";
+    }
+
+    function done(bytes memory state, uint start, uint end) internal pure returns (bytes memory) {
+        if (end <= start) revert NoOperation();
+        return state;
+    }
+
+    function callTo(uint node, uint value, bytes memory data) internal returns (bytes memory out) {
+        bool success;
+        address addr = localNodeAddr(ensureTrusted(node));
+        (success, out) = payable(addr).call{value: value}(data);
+        if (!success) {
+            revert FailedCall(addr, node, bytes4(data), out);
+        }
+    }
+}

package/contracts/core/Validator.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {ECDSA} from "../utils/ECDSA.sol";
+
+abstract contract Validator {
+    using ECDSA for bytes32;
+
+    error InvalidProof();
+    error InvalidSigner();
+    error InvalidNonce();
+
+    mapping(address account => mapping(uint192 key => uint64)) internal nonces;
+
+    function recover(bytes32 hash, bytes calldata sig) private pure returns (address) {
+        return hash.toEthSignedMessageHash().tryRecoverCalldata(sig);
+    }
+
+    // @dev proof is (bytes20 signer, bytes65 sig)
+    function verify(bytes32 hash, uint192 nonce, bytes calldata proof) internal returns (address) {
+        if (proof.length != 85) revert InvalidProof();
+
+        address account = address(bytes20(proof[0:20]));
+        address signer = recover(hash, proof[20:]);
+
+        if (account == address(0) || signer != account) revert InvalidSigner();
+        if (nonces[account][nonce]++ != 0) revert InvalidNonce();
+
+        return account;
+    }
+}

package/contracts/events/Access.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Access(uint indexed host, uint node, bool trusted)";
+
+abstract contract AccessEvent is EventEmitter {
+    event Access(uint indexed host, uint node, bool trusted);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Asset.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Asset(uint indexed host, bytes32 name, bytes4 prefix, string format)";
+
+abstract contract AssetEvent is EventEmitter {
+    event Asset(uint indexed host, bytes32 name, bytes4 prefix, string format);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Balance.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Balance(bytes32 indexed account, bytes32 asset, bytes32 meta, uint balance, int change, uint access)";
+
+abstract contract BalanceEvent is EventEmitter {
+    event Balance(bytes32 indexed account, bytes32 asset, bytes32 meta, uint balance, int change, uint access);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Collateral.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Collateral(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint access)";
+
+// Query should be provided for the access command to get the exact colleteral.
+abstract contract CollateralEvent is EventEmitter {
+    event Collateral(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint access);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Command.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Command(uint indexed host, string name, string schema, uint cid, uint8 stateIn, uint8 stateOut)";
+
+abstract contract CommandEvent is EventEmitter {
+    event Command(uint indexed host, string name, string schema, uint cid, uint8 stateIn, uint8 stateOut);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Debt.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Debt(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint mode, uint access)";
+
+// Query should be provided for the access command to get the exact debt.
+abstract contract DebtEvent is EventEmitter {
+    event Debt(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint mode, uint access);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Deposit.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Deposit(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint cid)";
+
+abstract contract DepositEvent is EventEmitter {
+    event Deposit(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint cid);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Emitter.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+// Activity: add ref and active to make trackable.
+abstract contract EventEmitter {
+    event EventAbi(string abi);
+}

package/contracts/events/Fastish.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Fastish(uint indexed host, bytes32 account, uint deadline, uint value)";
+
+abstract contract FastishEvent is EventEmitter {
+    event Fastish(uint indexed host, bytes32 account, uint deadline, uint value);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Governed.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Governed(uint indexed host, uint deadline, uint value)";
+
+abstract contract GovernedEvent is EventEmitter {
+    event Governed(uint indexed host, uint deadline, uint value);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/HostAnnounced.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event HostAnnounced(uint indexed host, uint blocknum, uint16 version, string namespace)";
+
+abstract contract HostAnnouncedEvent is EventEmitter {
+    event HostAnnounced(uint indexed host, uint blocknum, uint16 version, string namespace);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Listing.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active, bool created)";
+
+abstract contract ListingEvent is EventEmitter {
+    event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active, bool created);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Peer.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Peer(uint indexed host, string name, string schema, uint pid)";
+
+abstract contract PeerEvent is EventEmitter {
+    event Peer(uint indexed host, string name, string schema, uint pid);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Quote.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Quote(uint indexed host, uint cid, string schema)";
+
+abstract contract QuoteEvent is EventEmitter {
+    event Quote(uint indexed host, uint cid, string schema);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/events/Withdraw.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+string constant ABI = "event Withdrawal(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint cid)";
+
+abstract contract WithdrawalEvent is EventEmitter {
+    event Withdrawal(bytes32 indexed account, bytes32 asset, bytes32 meta, uint amount, uint cid);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/contracts/interfaces/IHostDiscovery.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+interface IHostDiscovery {
+    function announceHost(uint id, uint blocknum, uint16 version, string calldata namespace) external;
+}

package/contracts/peer/AllowAssets.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {ASSET, ASSET_KEY, BlockRef} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "peerAllowAssets";
+
+abstract contract PeerAllowAssets is PeerBase {
+    uint internal immutable peerAllowAssetsId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, NAME, ASSET, peerAllowAssetsId);
+    }
+
+    function peerAllowAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
+
+    function peerAllowAssets(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            BlockRef memory ref = Blocks.from(request, q);
+            if (ref.key != ASSET_KEY) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset(request);
+            peerAllowAsset(asset, meta);
+            q = ref.end;
+        }
+        return done(0, q);
+    }
+}

package/contracts/peer/Base.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {OperationBase} from "../core/Operation.sol";
+import {PeerEvent} from "../events/Peer.sol";
+import {toPeerId, toPeerSelector} from "../utils/Ids.sol";
+
+error NoResponse();
+
+abstract contract PeerBase is OperationBase, PeerEvent {
+    modifier onlyPeer() {
+        enforceCaller(msg.sender);
+        _;
+    }
+
+    function peerId(string memory name) internal view returns (uint) {
+        return toPeerId(toPeerSelector(name), address(this));
+    }
+}

package/contracts/peer/DenyAssets.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {ASSET, ASSET_KEY, BlockRef} from "../blocks/Schema.sol";
+import {Blocks} from "../blocks/Readers.sol";
+using Blocks for BlockRef;
+
+string constant NAME = "peerDenyAssets";
+
+abstract contract PeerDenyAssets is PeerBase {
+    uint internal immutable peerDenyAssetsId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, NAME, ASSET, peerDenyAssetsId);
+    }
+
+    function peerDenyAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
+
+    function peerDenyAssets(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            BlockRef memory ref = Blocks.from(request, q);
+            if (ref.key != ASSET_KEY) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset(request);
+            peerDenyAsset(asset, meta);
+            q = ref.end;
+        }
+        return done(0, q);
+    }
+}