@rootzero/contracts 0.2.0

package/contracts/commands/Transfer.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { Keys, Schemas, Blocks, Block } from "../Blocks.sol";
+using Blocks for Block;
+
+string constant NAME = "transfer";
+string constant REQUEST = string.concat(Schemas.Amount, ">", Schemas.Recipient);
+
+abstract contract Transfer is CommandBase {
+    uint internal immutable transferId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, REQUEST, transferId, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to transfer funds from `from` to `to`.
+    /// Called once per AMOUNT>RECIPIENT pair in the request.
+    function transfer(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    /// @dev Override to customize request parsing or batching for transfers.
+    /// The default implementation iterates AMOUNT>RECIPIENT pairs and calls
+    /// `transfer(from, to, asset, meta, amount)` for each one.
+    function transfer(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
+        uint q = 0;
+        while (q < request.length) {
+            Block memory ref = Blocks.from(request, q);
+            if (ref.key != Keys.Amount) break;
+            (bytes32 asset, bytes32 meta, uint amount) = ref.unpackAmount();
+            bytes32 to = ref.innerRecipientAt(ref.bound);
+            transfer(from, to, asset, meta, amount);
+            q = ref.cursor;
+        }
+
+        return done(0, q);
+    }
+
+    function transfer(
+        CommandContext calldata c
+    ) external payable onlyCommand(transferId, c.target) returns (bytes memory) {
+        return transfer(c.account, c.request);
+    }
+}

package/contracts/commands/Unstake.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { AssetAmount, Blocks, Block, Writers, Writer, Keys } from "../Blocks.sol";
+
+string constant UBTB = "unstakeBalanceToBalances";
+
+using Blocks for Block;
+using Writers for Writer;
+
+abstract contract UnstakeBalanceToBalances is CommandBase {
+    uint internal immutable unstakeBalanceToBalancesId = commandId(UBTB);
+    uint private immutable outScale;
+
+    constructor(string memory route, uint scaledRatio) {
+        outScale = scaledRatio;
+        emit Command(host, UBTB, route, unstakeBalanceToBalancesId, Channels.Balances, Channels.Balances);
+    }
+
+    /// @dev Override to unstake or redeem a balance position.
+    /// Implementations may append one or more BALANCE blocks to `out`.
+    function unstakeBalanceToBalances(
+        bytes32 account,
+        AssetAmount memory balance,
+        Block memory rawRoute,
+        Writer memory out
+    ) internal virtual;
+
+    function unstakeBalanceToBalances(
+        CommandContext calldata c
+    ) external payable onlyCommand(unstakeBalanceToBalancesId, 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();
+            unstakeBalanceToBalances(c.account, balance, route, writer);
+            i = ref.cursor;
+        }
+
+        return writer.finish();
+    }
+}

package/contracts/commands/Withdraw.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandContext, CommandBase, Channels } from "./Base.sol";
+import { Keys, Schemas, Blocks, Block } from "../Blocks.sol";
+using Blocks for Block;
+
+string constant NAME = "withdraw";
+
+// @dev Use `withdraw` for externally delivered assets; use `creditBalanceToAccount` for internal balance credits.
+abstract contract Withdraw is CommandBase {
+    uint internal immutable withdrawId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Recipient, withdrawId, Channels.Balances, Channels.Setup);
+    }
+
+    /// @dev Override to send funds to `account`.
+    /// Called once per BALANCE block in state.
+    function withdraw(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function withdraw(
+        CommandContext calldata c
+    ) external payable onlyCommand(withdrawId, 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();
+            withdraw(to, asset, meta, amount);
+            i = ref.cursor;
+        }
+
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Allocate.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 { HostAmount, Keys, Schemas, Blocks, Block } from "../../Blocks.sol";
+using Blocks for Block;
+
+string constant NAME = "allocate";
+
+abstract contract Allocate is CommandBase {
+    uint internal immutable allocateId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Allocation, allocateId, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to apply a single allocation entry.
+    /// Called once per ALLOCATION block in the request.
+    function allocate(uint host, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+
+    function allocate(CommandContext calldata c) external payable onlyAdmin(c.account) onlyCommand(allocateId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Allocation) break;
+            HostAmount memory v = ref.toAllocationValue();
+            allocate(v.host, v.asset, v.meta, v.amount);
+            i = ref.cursor;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/AllowAssets.sol

@@ -0,0 +1,34 @@
+// 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";
+using Blocks for Block;
+
+string constant NAME = "allowAssets";
+
+abstract contract AllowAssets is CommandBase {
+    uint internal immutable allowAssetsId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Asset, allowAssetsId, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to allow a single asset/meta pair.
+    /// Called once per ASSET block in the request.
+    function allowAsset(bytes32 asset, bytes32 meta) internal virtual returns (bool);
+
+    function allowAssets(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(allowAssetsId, c.target) returns (bytes memory) {
+        uint i = 0;
+        while (i < c.request.length) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Asset) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset();
+            allowAsset(asset, meta);
+            i = ref.cursor;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Authorize.sol

@@ -0,0 +1,30 @@
+// 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";
+using Blocks for Block;
+
+string constant NAME = "authorize";
+
+abstract contract Authorize is CommandBase {
+    uint internal immutable authorizeId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Node, authorizeId, Channels.Setup, Channels.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) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Node) break;
+            uint node = ref.unpackNode();
+            access(node, true);
+            i = ref.cursor;
+        }
+        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, Channels } from "../Base.sol";
+import { Keys, Schemas, Blocks, Block } from "../../Blocks.sol";
+using Blocks for Block;
+
+string constant NAME = "denyAssets";
+
+abstract contract DenyAssets is CommandBase {
+    uint internal immutable denyAssetsId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Asset, denyAssetsId, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to deny a single asset/meta pair.
+    /// Called once per ASSET block in the request.
+    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) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Asset) break;
+            (bytes32 asset, bytes32 meta) = ref.unpackAsset();
+            denyAsset(asset, meta);
+            i = ref.cursor;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Destroy.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { CommandBase, CommandContext, Channels } from "../Base.sol";
+import { Blocks, Block } 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, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to run host teardown or destruction logic using the
+    /// decoded route.
+    function destroy(Block memory rawRoute) internal virtual;
+
+    function destroy(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(destroyId, c.target) returns (bytes memory) {
+        Block memory route = Blocks.routeFrom(c.request, 0);
+        destroy(route);
+        return done(0, route.cursor);
+    }
+}

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, Channels } from "../Base.sol";
+import { Blocks, Block } 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, Channels.Setup, Channels.Setup);
+    }
+
+    /// @dev Override to run host initialization logic using the decoded route.
+    function init(Block memory rawRoute) internal virtual;
+
+    function init(
+        CommandContext calldata c
+    ) external payable onlyAdmin(c.account) onlyCommand(initId, c.target) returns (bytes memory) {
+        Block memory route = Blocks.routeFrom(c.request, 0);
+        init(route);
+        return done(0, route.cursor);
+    }
+}

package/contracts/commands/admin/Relocate.sol

@@ -0,0 +1,30 @@
+// 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";
+using Blocks for Block;
+
+string constant NAME = "relocate";
+
+abstract contract Relocate is CommandBase {
+    uint internal immutable relocateId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Funding, relocateId, Channels.Setup, Channels.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) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Funding) break;
+            (uint host, uint amount) = ref.unpackFunding();
+            callTo(host, amount, "");
+            i = ref.cursor;
+        }
+        return done(0, i);
+    }
+}

package/contracts/commands/admin/Unauthorize.sol

@@ -0,0 +1,30 @@
+// 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";
+using Blocks for Block;
+
+string constant NAME = "unauthorize";
+
+abstract contract Unauthorize is CommandBase {
+    uint internal immutable unauthorizeId = commandId(NAME);
+
+    constructor() {
+        emit Command(host, NAME, Schemas.Node, unauthorizeId, Channels.Setup, Channels.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) {
+            Block memory ref = Blocks.from(c.request, i);
+            if (ref.key != Keys.Node) break;
+            uint node = ref.unpackNode();
+            access(node, false);
+            i = ref.cursor;
+        }
+        return done(0, i);
+    }
+}

package/contracts/core/Access.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { AccessEvent } from "../events/Access.sol";
+import { Accounts } from "../utils/Accounts.sol";
+import { Ids } from "../utils/Ids.sol";
+import { addrOr } from "../utils/Utils.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 = Accounts.toAdmin(commander);
+        host = Ids.toHost(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[Ids.toHost(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,23 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {BalanceEvent} from "../events/Balance.sol";
+
+error InsufficientFunds();
+
+abstract contract Balances is BalanceEvent {
+    mapping(bytes32 account => mapping(bytes32 ref => uint amount)) internal balances;
+
+    function debitFrom(bytes32 account, bytes32 ref, uint amount) internal returns (uint balance) {
+        balance = balances[account][ref];
+        if (balance < amount) revert InsufficientFunds();
+        unchecked {
+            balance -= amount;
+        }
+        balances[account][ref] = balance;
+    }
+
+    function creditTo(bytes32 account, bytes32 ref, uint amount) internal returns (uint balance) {
+        balance = balances[account][ref] += amount;
+    }
+}

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 { Ids } from "../utils/Ids.sol";
+
+abstract contract HostDiscovery is HostAnnouncedEvent, IHostDiscovery {
+    function announceHost(uint id, uint blocknum, uint16 version, string calldata namespace) external {
+        emit HostAnnounced(Ids.host(id, msg.sender), blocknum, version, namespace);
+    }
+}
+
+abstract contract Host is Authorize, Unauthorize, Relocate {
+    constructor(address cmdr, uint16 version, string memory namespace) AccessControl(cmdr) {
+        if (cmdr == address(0) || cmdr == address(this) || cmdr.code.length == 0) return;
+        IHostDiscovery(cmdr).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 { Assets } from "../utils/Assets.sol";
+import { Ids } 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 = Assets.toValue();
+
+    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 = Ids.nodeAddr(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, uint32 prefix, string format)";
+
+abstract contract AssetEvent is EventEmitter {
+    event Asset(uint indexed host, bytes32 name, uint32 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);
+}