@rootzero/contracts 0.6.0 → 0.6.2

package/blocks/Cursors.sol

@@ -260,6 +260,29 @@ library Cursors {
         return create64(Keys.Bounty, bytes32(bounty), relayer);
     }
 
+    /// @notice Encode a MINIMUMS block.
+    /// @param a First minimum amount.
+    /// @param b Second minimum amount.
+    /// @return Encoded MINIMUMS block bytes.
+    function toMinimumsBlock(uint a, uint b) internal pure returns (bytes memory) {
+        return create64(Keys.Minimums, bytes32(a), bytes32(b));
+    }
+
+    /// @notice Encode a MAXIMUMS block.
+    /// @param a First maximum amount.
+    /// @param b Second maximum amount.
+    /// @return Encoded MAXIMUMS block bytes.
+    function toMaximumsBlock(uint a, uint b) internal pure returns (bytes memory) {
+        return create64(Keys.Maximums, bytes32(a), bytes32(b));
+    }
+
+    /// @notice Encode a FEE block.
+    /// @param amount Fee amount.
+    /// @return Encoded FEE block bytes.
+    function toFeeBlock(uint amount) internal pure returns (bytes memory) {
+        return create32(Keys.Fee, bytes32(amount));
+    }
+
     /// @notice Encode a BALANCE block.
     /// @param asset Asset identifier.
     /// @param meta Asset metadata slot.
@@ -401,6 +424,26 @@ library Cursors {
         value.amount = uint(bytes32(msg.data[abs + 64:abs + 96]));
     }
 
+    /// @notice Consume a MINIMUMS block and return the two minimum amounts.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First minimum amount.
+    /// @return b Second minimum amount.
+    function unpackMinimums(Cur memory cur) internal pure returns (uint a, uint b) {
+        uint abs = consume(cur, Keys.Minimums, 64, 64);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+    }
+
+    /// @notice Consume a MAXIMUMS block and return the two maximum amounts.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First maximum amount.
+    /// @return b Second maximum amount.
+    function unpackMaximums(Cur memory cur) internal pure returns (uint a, uint b) {
+        uint abs = consume(cur, Keys.Maximums, 64, 64);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+    }
+
     /// @notice Consume a MAXIMUM block and return its fields as separate values.
     /// @param cur Cursor; advanced past the block.
     /// @return asset Asset identifier.
@@ -468,6 +511,26 @@ library Cursors {
         amount = uint(bytes32(msg.data[abs:abs + 32]));
     }
 
+    /// @notice Consume a FEE block and return the amount.
+    /// @param cur Cursor; advanced past the block.
+    /// @return amount Fee amount.
+    function unpackFee(Cur memory cur) internal pure returns (uint amount) {
+        uint abs = consume(cur, Keys.Fee, 32, 32);
+        amount = uint(bytes32(msg.data[abs:abs + 32]));
+    }
+
+    /// @notice Consume a BOUNDS block and return the signed min and max values.
+    /// @param cur Cursor; advanced past the block.
+    /// @return min Lower signed bound.
+    /// @return max Upper signed bound.
+    function unpackBounds(Cur memory cur) internal pure returns (int min, int max) {
+        uint abs = consume(cur, Keys.Bounds, 64, 64);
+        assembly ("memory-safe") {
+            min := calldataload(abs)
+            max := calldataload(add(abs, 0x20))
+        }
+    }
+
     /// @notice Consume an ASSET block and return the asset descriptor fields.
     /// @param cur Cursor; advanced past the block.
     /// @return asset Asset identifier.
@@ -538,6 +601,16 @@ library Cursors {
         cur.i = next;
     }
 
+    /// @notice Consume a PATH block and return the raw payload as a calldata slice.
+    /// The payload length is variable; the returned slice covers the entire payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return data Raw path payload bytes.
+    function unpackPath(Cur memory cur) internal pure returns (bytes calldata data) {
+        (uint abs, uint next) = expect(cur, cur.i, Keys.Path, 0, 0);
+        data = msg.data[abs:cur.offset + next];
+        cur.i = next;
+    }
+
     /// @notice Consume a ROUTE block with a single uint payload.
     /// @param cur Cursor; advanced past the block.
     /// @return value Decoded uint value.

package/blocks/Keys.sol

@@ -14,14 +14,24 @@ library Keys {
     bytes4 constant Custody = bytes4(keccak256("custody(uint host, bytes32 asset, bytes32 meta, uint amount)"));
     /// @dev Minimum acceptable output — (bytes32 asset, bytes32 meta, uint amount)
     bytes4 constant Minimum = bytes4(keccak256("minimum(bytes32 asset, bytes32 meta, uint amount)"));
+    /// @dev Pair of minimum amounts — (uint a, uint b)
+    bytes4 constant Minimums = bytes4(keccak256("minimums(uint a, uint b)"));
     /// @dev Maximum allowable spend — (bytes32 asset, bytes32 meta, uint amount)
     bytes4 constant Maximum = bytes4(keccak256("maximum(bytes32 asset, bytes32 meta, uint amount)"));
+    /// @dev Pair of maximum amounts — (uint a, uint b)
+    bytes4 constant Maximums = bytes4(keccak256("maximums(uint a, uint b)"));
+    /// @dev Signed min/max bounds — (int min, int max)
+    bytes4 constant Bounds = bytes4(keccak256("bounds(int min, int max)"));
+    /// @dev Fee amount — (uint amount)
+    bytes4 constant Fee = bytes4(keccak256("fee(uint amount)"));
     /// @dev Hard stop / iteration sentinel — ()
     bytes4 constant Break = bytes4(keccak256("break()"));
     /// @dev Bundle wrapper — (bytes data); payload is an embedded block stream
     bytes4 constant Bundle = bytes4(keccak256("bundle(bytes data)"));
     /// @dev Extensible routing field — (bytes data); layout is command-defined
     bytes4 constant Route = bytes4(keccak256("route(bytes data)"));
+    /// @dev Opaque path payload — (bytes data); e.g. a Uniswap path encoding
+    bytes4 constant Path = bytes4(keccak256("path(bytes data)"));
     /// @dev Plain scalar amount — (uint amount)
     bytes4 constant Quantity = bytes4(keccak256("quantity(uint amount)"));
     /// @dev Ratio or rate value — (uint value)

package/blocks/Schema.sol

@@ -12,9 +12,14 @@ library Schemas {
     string constant Balance = "balance(bytes32 asset, bytes32 meta, uint amount)";
     string constant Custody = "custody(uint host, bytes32 asset, bytes32 meta, uint amount)";
     string constant Minimum = "minimum(bytes32 asset, bytes32 meta, uint amount)";
+    string constant Minimums = "minimums(uint a, uint b)";
     string constant Maximum = "maximum(bytes32 asset, bytes32 meta, uint amount)";
+    string constant Maximums = "maximums(uint a, uint b)";
+    string constant Bounds = "bounds(int min, int max)";
+    string constant Fee = "fee(uint amount)";
     string constant Break = "break()";
     string constant Route = "route(bytes data)";
+    string constant Path = "path(bytes data)";
     string constant RouteEmpty = "route()";
     string constant Quantity = "quantity(uint amount)";
     string constant Rate = "rate(uint value)";
@@ -91,6 +96,14 @@ library Sizes {
     uint constant Auth = 157;
     /// @dev BALANCE block: 8 header + 32 asset + 32 meta + 32 amount = 104 bytes
     uint constant Balance = 104;
+    /// @dev MINIMUMS block: 8 header + 32 a + 32 b = 72 bytes
+    uint constant Minimums = 72;
+    /// @dev MAXIMUMS block: 8 header + 32 a + 32 b = 72 bytes
+    uint constant Maximums = 72;
+    /// @dev BOUNDS block: 8 header + 32 min + 32 max = 72 bytes
+    uint constant Bounds = 72;
+    /// @dev FEE block: 8 header + 32 amount = 40 bytes
+    uint constant Fee = 40;
     /// @dev BOUNTY block: 8 header + 32 amount + 32 relayer = 72 bytes
     uint constant Bounty = 72;
     /// @dev CUSTODY block: 8 header + 32 host + 32 asset + 32 meta + 32 amount = 136 bytes

package/commands/Base.sol

@@ -74,19 +74,26 @@ abstract contract CommandPayable is CommandBase {
     /// Override `settleValue` to implement refund or forwarding behavior instead.
     error UnusedValue(uint remaining);
 
-    /// @notice Settle any remaining native value after command execution.
-    /// The default implementation rejects leftover value by reverting with
-    /// `UnusedValue(remaining)`. Override this hook to refund or redirect
-    /// unused value for specific payable commands.
+    /// @notice Drains the command budget and settles any remaining native value.
+    /// @dev Calls the amount-based `settleValue` hook only when some value remains.
     /// @param account Caller's account identifier for the current invocation.
     /// @param budget Mutable native-value budget used during command execution.
     function settleValue(
         bytes32 account,
         Budget memory budget
-    ) internal virtual {
-        account;
+    ) internal {
         uint remaining = Values.drain(budget);
-        if (remaining != 0) revert UnusedValue(remaining);
+        if (remaining != 0) settleValue(account, remaining);
+    }
+
+    /// @notice Handles leftover native value after a payable command has finished.
+    /// @dev Override this hook to refund or redirect unused value for a command.
+    /// The default implementation rejects any leftover amount.
+    /// @param account Caller's account identifier for the current invocation.
+    /// @param remaining Unspent native value left in the budget, in wei.
+    function settleValue(bytes32 account, uint remaining) internal virtual {
+        account;
+        revert UnusedValue(remaining);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",

package/utils/Assets.sol

@@ -62,6 +62,31 @@ library Assets {
         return bytes1(asset) == 0x20 ? asset : keccak256(bytes.concat(asset, meta));
     }
 
+    /// @notice Return true when two local ERC-20 assets are already in canonical token-address order.
+    /// Useful for pair-style integrations that require a stable token ordering
+    /// regardless of the caller's input order.
+    /// Reverts if either asset is not a local ERC-20 asset.
+    /// @param a First ERC-20 asset identifier.
+    /// @param b Second ERC-20 asset identifier.
+    /// @return ordered Whether `a`'s token address is lower than `b`'s token address.
+    function isSortedErc20(bytes32 a, bytes32 b) internal view returns (bool ordered) {
+        return erc20Addr(a) < erc20Addr(b);
+    }
+
+    /// @notice Extract the token addresses for two local ERC-20 assets and report whether they are already ordered.
+    /// The returned addresses preserve the original input order.
+    /// Reverts if either asset is not a local ERC-20 asset.
+    /// @param a First ERC-20 asset identifier.
+    /// @param b Second ERC-20 asset identifier.
+    /// @return addrA Token address extracted from `a`.
+    /// @return addrB Token address extracted from `b`.
+    /// @return ordered Whether `addrA` is lower than `addrB`.
+    function erc20Addrs(bytes32 a, bytes32 b) internal view returns (address addrA, address addrB, bool ordered) {
+        addrA = erc20Addr(a);
+        addrB = erc20Addr(b);
+        ordered = addrA < addrB;
+    }
+
     /// @notice Extract the ERC-20 contract address from an asset ID.
     /// Reverts if `asset` is not a local ERC-20 asset.
     /// @param asset ERC-20 asset identifier.