@rootzero/contracts 0.4.0 → 0.5.0

package/{Cursors.sol → contracts/Cursors.sol}

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-// Aggregator: re-exports all block stream primitives (Cursors, Writers, Mem, Schema, Keys).
+// Aggregator: re-exports all block stream primitives (Cursors, Writers, Schema, Keys).
 // Import this file to get access to the full block encoding/decoding surface in one import.
 
 import { HostAmount, UserAmount, HostAsset, Tx, AssetAmount } from "./blocks/Schema.sol";
 import { Keys } from "./blocks/Keys.sol";
 import { Schemas } from "./blocks/Schema.sol";
 import { Cursors, Cur } from "./blocks/Cursors.sol";
-import { Mem, MemRef } from "./blocks/Mem.sol";
 import { Writer, Writers } from "./blocks/Writers.sol";
 
 

package/{blocks → contracts/blocks}/Cursors.sol

@@ -778,6 +778,15 @@ library Cursors {
         cur.i += 104;
     }
 
+    /// @notice Consume a MINIMUM block, assert it matches the expected asset and meta, and require `amount` to satisfy it.
+    /// @param cur Cursor; advanced past the block.
+    /// @param asset Expected asset identifier.
+    /// @param meta Expected metadata slot.
+    /// @param amount Actual amount that must be at least the minimum from the block.
+    function requireMinimum(Cur memory cur, bytes32 asset, bytes32 meta, uint amount) internal pure {
+        if (requireMinimum(cur, asset, meta) > amount) revert UnexpectedValue();
+    }
+
     /// @notice Consume a MAXIMUM block and assert it matches the expected asset and meta.
     /// @param cur Cursor; advanced past the block.
     /// @param asset Expected asset identifier.
@@ -788,6 +797,15 @@ library Cursors {
         cur.i += 104;
     }
 
+    /// @notice Consume a MAXIMUM block, assert it matches the expected asset and meta, and require `amount` to satisfy it.
+    /// @param cur Cursor; advanced past the block.
+    /// @param asset Expected asset identifier.
+    /// @param meta Expected metadata slot.
+    /// @param amount Actual amount that must be at most the maximum from the block.
+    function requireMaximum(Cur memory cur, bytes32 asset, bytes32 meta, uint amount) internal pure {
+        if (requireMaximum(cur, asset, meta) < amount) revert UnexpectedValue();
+    }
+
     /// @notice Consume a CUSTODY block and assert it belongs to the expected host.
     /// @param cur Cursor; advanced past the block.
     /// @param host Expected host node ID.

package/{blocks → contracts/blocks}/Keys.sol

@@ -30,7 +30,7 @@ library Keys {
     bytes4 constant Party = bytes4(keccak256("party(bytes32 account)"));
     /// @dev Destination account — (bytes32 account)
     bytes4 constant Recipient = bytes4(keccak256("recipient(bytes32 account)"));
-    /// @dev Settled transfer record — (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)
+    /// @dev Transfer record passed through the pipeline — (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)
     bytes4 constant Transaction = bytes4(keccak256("tx(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)"));
     /// @dev Sub-command invocation — (uint target, uint value, bytes request)
     bytes4 constant Step = bytes4(keccak256("step(uint target, uint value, bytes request)"));

package/{blocks → contracts/blocks}/Schema.sol

@@ -143,7 +143,7 @@ struct HostAsset {
     bytes32 meta;
 }
 
-/// @notice Settled transfer record written to transaction state.
+/// @notice Transfer payload used across the pipeline and later consumed by settlement.
 struct Tx {
     /// @dev Sender account identifier.
     bytes32 from;

package/{blocks → contracts/blocks}/Writers.sol

@@ -259,7 +259,7 @@ library Writers {
     /// @notice Write a TRANSACTION block directly into `dst` at byte offset `i`.
     /// @param dst Destination buffer; must have at least `i + Sizes.Transaction` bytes.
     /// @param i Write offset within `dst`.
-    /// @param value Transaction fields to encode.
+    /// @param value Transfer record fields to encode.
     /// @return next Byte offset immediately after the written block.
     function writeTxBlock(bytes memory dst, uint i, Tx memory value) internal pure returns (uint next) {
         next = i + Sizes.Transaction;
@@ -279,7 +279,7 @@ library Writers {
 
     /// @notice Append a TRANSACTION block from a struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.Transaction`.
-    /// @param value Transaction fields to encode.
+    /// @param value Transfer record fields to encode.
     function appendTx(Writer memory writer, Tx memory value) internal pure {
         writer.i = writeTxBlock(writer.dst, writer.i, value);
     }

package/{commands → contracts/commands}/Provision.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {CommandContext, CommandBase, State} from "./Base.sol";
-import {Cursors, Cur, Keys, Schemas, Writer, Writers} from "../Cursors.sol";
+import {Cursors, Cur, Schemas, Writer, Writers} from "../Cursors.sol";
 using Cursors for Cur;
 using Writers for Writer;
 
@@ -38,8 +38,6 @@ abstract contract Provision is CommandBase, ProvisionHook {
         CommandContext calldata c
     ) external payable onlyCommand(provisionId, c.target) returns (bytes memory) {
         (Cur memory request, uint count, ) = cursor(c.request, 1);
-        (bytes4 key, ) = request.peek(0);
-        if (key != Keys.Bundle) revert Writers.EmptyRequest();
         Writer memory writer = Writers.allocCustodies(count);
 
         while (request.i < request.bound) {

package/{commands → contracts/commands}/Settle.sol

@@ -3,31 +3,27 @@ pragma solidity ^0.8.33;
 
 import { CommandContext, CommandBase, State } from "./Base.sol";
 import { Cursors, Cur, Tx } from "../Cursors.sol";
+import { TransferHook } from "./Transfer.sol";
 using Cursors for Cur;
 
 string constant NAME = "settle";
 
 /// @title Settle
-/// @notice Command that settles each TRANSACTION state block via a virtual hook.
+/// @notice Command that consumes each TRANSACTION state block and settles it through the shared transfer hook.
 /// Produces no output state.
-abstract contract Settle is CommandBase {
+abstract contract Settle is CommandBase, TransferHook {
     uint internal immutable settleId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, "", settleId, State.Transactions, State.Empty);
     }
 
-    /// @notice Override to settle a single transaction block.
-    /// Called once per TRANSACTION block in state.
-    /// @param value Decoded transaction (from, to, asset, meta, amount).
-    function settle(Tx memory value) internal virtual;
-
     function settle(CommandContext calldata c) external payable onlyCommand(settleId, c.target) returns (bytes memory) {
         (Cur memory state, , ) = cursor(c.state, 1);
 
         while (state.i < state.bound) {
             Tx memory value = state.unpackTxValue();
-            settle(value);
+            transfer(value);
         }
 
         state.complete();

package/{commands → contracts/commands}/Transfer.sol

@@ -2,39 +2,46 @@
 pragma solidity ^0.8.33;
 
 import { CommandContext, CommandBase, State } from "./Base.sol";
-import { Cursors, Cur, Schemas } from "../Cursors.sol";
+import { Cursors, Cur, Schemas, Tx } from "../Cursors.sol";
+import { Accounts } from "../utils/Accounts.sol";
 using Cursors for Cur;
 
 string constant NAME = "transfer";
 string constant INPUT = string.concat(Schemas.Amount, "&", Schemas.Recipient);
 
+abstract contract TransferHook {
+    /// @notice Override to execute a single transfer record from the request pipeline.
+    /// Called once per bundled AMOUNT+RECIPIENT pair in the request.
+    /// @param value Decoded transfer record (from, to, asset, meta, amount).
+    function transfer(Tx memory value) internal virtual;
+}
+
 /// @title Transfer
 /// @notice Command that transfers assets from a caller to recipients specified in
 /// bundled AMOUNT+RECIPIENT request blocks. Produces no state output.
-/// The virtual `transfer(from, input)` hook is called once per bundle.
-abstract contract Transfer is CommandBase {
+/// The virtual `transfer(value)` hook is called once per bundle.
+abstract contract Transfer is CommandBase, TransferHook {
     uint internal immutable transferId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, INPUT, transferId, State.Empty, State.Empty);
     }
 
-    /// @notice Override to execute a single transfer described by the current `input` position.
-    /// Called once per bundled AMOUNT+RECIPIENT pair in the request.
-    /// @param from Source account identifier.
-    /// @param input Live request cursor positioned at the current bundle.
-    function transfer(bytes32 from, Cur memory input) internal virtual;
-
     /// @notice Override to customize request parsing or batching for transfers.
-    /// The default implementation iterates bundles and calls `transfer(from, input)` for each.
+    /// The default implementation iterates bundles and calls `transfer(value)` for each.
     /// @param from Source account identifier.
     /// @param request Full request bytes.
     /// @return Empty bytes (transfers produce no state output).
     function transfer(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
         (Cur memory input, , ) = cursor(request, 1);
+        Tx memory value;
+        value.from = from;
 
         while (input.i < input.bound) {
-            transfer(from, input);
+            Cur memory bundle = input.bundle();
+            (value.asset, value.meta, value.amount) = bundle.unpackAmount();
+            value.to = Accounts.ensure(bundle.unpackRecipient());
+            transfer(value);
         }
 
         input.complete();

package/{events → contracts/events}/RootZero.sol

@@ -3,15 +3,14 @@ pragma solidity ^0.8.33;
 
 import { EventEmitter } from "./Emitter.sol";
 
-string constant ABI = "event RootZero(uint indexed host, bytes32 account, uint deadline, uint value)";
+string constant ABI = "event RootZero(bytes32 indexed account, uint deadline, uint value)";
 
 /// @notice Emitted for root-level protocol actions (e.g. governance or protocol-wide operations).
 abstract contract RootZeroEvent is EventEmitter {
-    /// @param host Host node ID where the action occurred.
     /// @param account Account identifier associated with the action.
     /// @param deadline Expiry timestamp of the action.
     /// @param value Native value associated with the action.
-    event RootZero(uint indexed host, bytes32 account, uint deadline, uint value);
+    event RootZero(bytes32 indexed account, uint deadline, uint value);
 
     constructor() {
         emit EventAbi(ABI);

package/contracts/peer/Settle.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PeerBase } from "./Base.sol";
+import { TransferHook } from "../commands/Transfer.sol";
+import { Cursors, Cur, Tx, Schemas } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+string constant NAME = "peerSettle";
+
+/// @title PeerSettle
+/// @notice Peer that consumes peer-supplied TRANSACTION blocks through the shared transfer hook.
+/// Each TRANSACTION block in the request calls `transfer(value)`. Restricted to trusted peers.
+abstract contract PeerSettle is PeerBase, TransferHook {
+    uint internal immutable peerSettleId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, NAME, Schemas.Transaction, peerSettleId);
+    }
+
+    /// @notice Execute the peer-settle call.
+    function peerSettle(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        (Cur memory state, , ) = cursor(request, 1);
+
+        while (state.i < state.bound) {
+            Tx memory value = state.unpackTxValue();
+            transfer(value);
+        }
+
+        state.complete();
+        return "";
+    }
+}

package/contracts/test/TestBorrowHost.sol

@@ -0,0 +1,72 @@
+// 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 } from "../blocks/Schema.sol";
+import { Cur, Cursors, Keys } from "../Cursors.sol";
+import { Ids } from "../utils/Ids.sol";
+
+using Cursors for Cur;
+
+contract TestBorrowHost is Host, BorrowAgainstCustodyToBalance {
+    event BorrowCalled(bytes32 account, bytes32 asset, bytes32 meta, uint amount, bytes inputData);
+
+    bytes32 public returnAsset;
+    bytes32 public returnMeta;
+    uint public returnAmount;
+
+    constructor(address cmdr) Host(address(0), 1, "test") BorrowAgainstCustodyToBalance("") {
+        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 borrowAgainstCustodyToBalance(
+        bytes32 account,
+        HostAmount memory custody,
+        Cur memory request
+    ) internal override returns (AssetAmount memory) {
+        if (request.i < request.len) {
+            bytes calldata inputData;
+            (bytes4 key, uint len) = request.peek(request.i);
+            if (key == Keys.Bundle) {
+                Cur memory bundle = request.bundle();
+                (key, len) = bundle.peek(bundle.i);
+                if (key == Keys.Route) {
+                    inputData = bundle.unpackRoute();
+                } else {
+                    uint next = bundle.i + 8 + len;
+                    inputData = msg.data[bundle.offset + bundle.i:bundle.offset + next];
+                    bundle.i = next;
+                }
+            } else if (key == Keys.Route) {
+                inputData = request.unpackRoute();
+            } else {
+                uint next = request.i + 8 + len;
+                inputData = msg.data[request.offset + request.i:request.offset + next];
+                request.i = next;
+            }
+            emit BorrowCalled(account, custody.asset, custody.meta, custody.amount, inputData);
+        } else {
+            emit BorrowCalled(account, custody.asset, custody.meta, custody.amount, "");
+        }
+        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,31 @@
+// 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 { Ids } 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(Ids.toHost(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,40 @@
+// 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 { Cursors, Cur, Keys } from "../Cursors.sol";
+import { Ids } from "../utils/Ids.sol";
+
+using Cursors for Cur;
+
+contract TestCreateHost is Host, Create {
+    event CreateCalled(bytes32 account, bytes inputData);
+
+    constructor(address cmdr)
+        Host(address(0), 1, "test")
+        Create("")
+    {
+        if (cmdr != address(0)) access(Ids.toHost(cmdr), true);
+    }
+
+    function create(bytes32 account, Cur memory input) internal override {
+        (bytes4 key, uint len) = input.peek(input.i);
+        bytes calldata inputData;
+        if (key == Keys.Route) {
+            inputData = input.unpackRoute();
+        } else {
+            uint next = input.i + 8 + len;
+            inputData = msg.data[input.offset + input.i:input.offset + next];
+            input.i = next;
+        }
+        emit CreateCalled(account, inputData);
+    }
+
+    function getCreateId() external view returns (uint) { return createId; }
+    function getAdminAccount() external view returns (bytes32) { return adminAccount; }
+}
+
+
+
+

package/contracts/test/TestCursorHelper.sol

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Tx, Sizes } from "../blocks/Schema.sol";
+import { Cur, Cursors, Writer } from "../Cursors.sol";
+import { Writers } from "../blocks/Writers.sol";
+
+using Cursors for Cur;
+using Writers for Writer;
+
+contract TestCursorHelper {
+    function testBlockHeader(bytes4 key, uint len) external pure returns (uint) {
+        return Writers.toBlockHeader(key, len);
+    }
+
+    function testWriteBalanceBlock(bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(Sizes.Balance);
+        w.appendBalance(asset, meta, amount);
+        return w.dst;
+    }
+
+    function testWriteCustodyBlock(
+        uint host_,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount
+    ) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(Sizes.Custody);
+        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(Sizes.Transaction);
+        w.appendTx(Tx({ from: from_, to: to_, asset: asset, meta: meta, amount: amount }));
+        return w.dst;
+    }
+
+    function testToBountyBlock(uint amount, bytes32 relayer) external pure returns (bytes memory) {
+        return Cursors.toBountyBlock(amount, relayer);
+    }
+
+    function testToBalanceBlock(bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        return Cursors.toBalanceBlock(asset, meta, amount);
+    }
+
+    function testToCustodyBlock(
+        uint host_,
+        bytes32 asset,
+        bytes32 meta,
+        uint amount
+    ) external pure returns (bytes memory) {
+        return Cursors.toCustodyBlock(host_, asset, meta, amount);
+    }
+
+    function testWriterFinishIncomplete() external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(Sizes.Balance);
+        return Writers.finish(w);
+    }
+
+    function testWriterFinish(bytes32 asset, bytes32 meta, uint amount) external pure returns (bytes memory) {
+        Writer memory w = Writers.alloc(Sizes.Balance * 2);
+        w.appendBalance(asset, meta, amount);
+        return Writers.finish(w);
+    }
+
+    function testUnpackBalance(bytes calldata source) external pure returns (bytes32 asset, bytes32 meta, uint amount) {
+        Cur memory cur = Cursors.open(source);
+        return cur.unpackBalance();
+    }
+
+    function testToTxValue(bytes calldata source) external pure returns (bytes32 from_, bytes32 to_, bytes32 asset, bytes32 meta, uint amount) {
+        Cur memory cur = Cursors.open(source);
+        Tx memory value = cur.unpackTxValue();
+        return (value.from, value.to, value.asset, value.meta, value.amount);
+    }
+
+    function testPrimeRun(bytes calldata source, uint group)
+        external
+        pure
+        returns (bytes4 key, uint count, uint quotient, uint offset, uint i, uint len, uint bound)
+    {
+        uint sourceOffset;
+        assembly ("memory-safe") {
+            sourceOffset := source.offset
+        }
+        Cur memory cur = Cursors.open(source);
+        (key, count, quotient) = cur.primeRun(group);
+        return (key, count, quotient, cur.offset - sourceOffset, cur.i, cur.len, cur.bound);
+    }
+
+    function testPeek(bytes calldata source, uint i) external pure returns (bytes4 key, uint len) {
+        Cur memory cur = Cursors.open(source);
+        return cur.peek(i);
+    }
+
+    function testCountRun(bytes calldata source, uint i, bytes4 key) external pure returns (uint total, uint next) {
+        Cur memory cur = Cursors.open(source);
+        return cur.countRun(i, key);
+    }
+
+    function testBundle(bytes calldata source) external pure returns (uint inputI, uint offset, uint len) {
+        uint sourceOffset;
+        assembly ("memory-safe") {
+            sourceOffset := source.offset
+        }
+        Cur memory cur = Cursors.open(source);
+        Cur memory out = cur.bundle();
+        return (cur.i, out.offset - sourceOffset, out.len);
+    }
+
+    function testUnpackStep(bytes calldata source) external pure returns (uint target, uint value, bytes calldata req, uint i) {
+        Cur memory cur = Cursors.open(source);
+        (target, value, req) = cur.unpackStep();
+        return (target, value, req, cur.i);
+    }
+
+    function testRequireAmount(
+        bytes calldata source,
+        bytes32 asset,
+        bytes32 meta
+    ) external pure returns (uint amount, uint i) {
+        Cur memory cur = Cursors.open(source);
+        amount = cur.requireAmount(asset, meta);
+        i = cur.i;
+    }
+
+    function testRequireAuth(bytes calldata source, uint cid) external pure returns (uint deadline, bytes calldata proof, uint i) {
+        Cur memory cur = Cursors.open(source);
+        (deadline, proof) = cur.requireAuth(cid);
+        return (deadline, proof, cur.i);
+    }
+
+    function testNodeAfter(bytes calldata source, uint group, uint backup) external pure returns (uint) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        return cur.nodeAfter(backup);
+    }
+
+    function testRecipientAfter(bytes calldata source, uint group, bytes32 backup) external pure returns (bytes32) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        return cur.recipientAfter(backup);
+    }
+
+    function testAuthLast(
+        bytes calldata source,
+        uint group,
+        uint cid
+    ) external pure returns (bytes32 hash, uint deadline, bytes calldata proof) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        return cur.authLast(cid);
+    }
+
+    function testCursorCompleteEmpty(bytes calldata source, uint group) external pure returns (bool) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        cur.complete();
+        return true;
+    }
+
+    function testCursorCompletePartial(bytes calldata source, uint group) external pure returns (bool) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        if (cur.bound > 0) {
+            (, uint len) = cur.peek(cur.i);
+            cur.i += 8 + len;
+        }
+        cur.complete();
+        return true;
+    }
+
+    function testCursorCompleteConsumed(bytes calldata source, uint group) external pure returns (bool) {
+        Cur memory cur = Cursors.open(source);
+        cur.primeRun(group);
+        while (cur.i < cur.bound) {
+            (, uint len) = cur.peek(cur.i);
+            cur.i += 8 + len;
+        }
+        cur.complete();
+        return true;
+    }
+
+}

package/contracts/test/TestDiscovery.sol

@@ -0,0 +1,9 @@
+// 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,19 @@
+// 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);
+    }
+}
+
+
+