@rootzero/contracts 1.0.1 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+Until the protocol reaches integration-stable status, minor versions may include
+breaking API changes. Breaking changes are called out explicitly.
+
+## 1.2.0
+
+### Breaking Changes
+
+- Removed human-readable names from Command, Admin, Peer, Query, Guard, and Chain discovery events.
+- Added the Labeled event and default labels for commands, admin commands, peers, queries, guards, and examples.
+- Added LABEL and STRING block schemas, plus cursor helpers for decoding labels supplied by callers.
+- Added the admin label command for publishing mutable namespaced labels.
+- Removed version and namespace fields from host Introduction events and host constructor introductions.
+
+## 1.1.0
+
+### Breaking Changes
+
+- Renamed local execution fields from `value` to `resources` in PIPE, CALL, and STEP schemas.
+- Interprets EVM value as the low 128 bits of packed `resources`.
+- Changed native value APIs and dispatch hooks to use `uint128` for actual EVM value.
+- Replaced the relay-specific hook with shared `DispatchPayableHook`.
+- `RelayPayable` now dispatches an encoded PIPE payload and settles leftover user command value.

package/Endpoints.sol

@@ -16,7 +16,7 @@ import { DebitAccount, DebitAccountHook } from "./commands/Debit.sol";
 import { Deposit, DepositHook, DepositPayable, DepositPayableHook } from "./commands/Deposit.sol";
 import { Payout, PayoutHook } from "./commands/Payout.sol";
 import { Provision, ProvisionHook, ProvisionPayable, ProvisionPayableHook } from "./commands/Provision.sol";
-import { RelayPayable, RelayPayableHook } from "./commands/Relay.sol";
+import { RelayPayable, DispatchPayableHook } from "./commands/Relay.sol";
 import { Withdraw, WithdrawHook } from "./commands/Withdraw.sol";
 
 // Admin commands
@@ -29,6 +29,7 @@ import { DenyAssets, DenyAssetsHook } from "./commands/admin/DenyAssets.sol";
 import { Dismiss } from "./commands/admin/Dismiss.sol";
 import { ExecutePayable } from "./commands/admin/Execute.sol";
 import { Init, InitHook } from "./commands/admin/Init.sol";
+import { Label } from "./commands/admin/Label.sol";
 import { Unauthorize } from "./commands/admin/Unauthorize.sol";
 
 // Peer endpoints

package/Events.sol

@@ -16,6 +16,7 @@ import { EventEmitter } from "./events/Emitter.sol";
 import { GuardEvent } from "./events/Guard.sol";
 import { GuardianEvent } from "./events/Guardian.sol";
 import { IntroductionEvent } from "./events/Introduction.sol";
+import { LabeledEvent } from "./events/Labeled.sol";
 import { LockedEvent } from "./events/Locked.sol";
 import { NodeEvent } from "./events/Node.sol";
 import { PeerEvent } from "./events/Peer.sol";

package/blocks/Cursors.sol

@@ -489,6 +489,13 @@ library Cursors {
         return createBlock(Keys.Bytes, data);
     }
 
+    /// @notice Encode a STRING block with a UTF-8 payload.
+    /// @param data String payload.
+    /// @return Encoded STRING block bytes.
+    function toStringBlock(string memory data) internal pure returns (bytes memory) {
+        return createBlock(Keys.String, bytes(data));
+    }
+
     /// @notice Encode a BOUNTY block.
     /// @param bounty Relayer reward amount.
     /// @param relayer Relayer account identifier.
@@ -518,20 +525,20 @@ library Cursors {
 
     /// @notice Encode a STEP block.
     /// @param target Command target identifier.
-    /// @param value Native value forwarded with the step.
+    /// @param resources Chain resources assigned to the step.
     /// @param request Raw nested request payload.
     /// @return Encoded STEP block bytes.
-    function toStepBlock(uint target, uint value, bytes memory request) internal pure returns (bytes memory) {
-        return createBlock(Keys.Step, bytes.concat(bytes32(target), bytes32(value), toBytesBlock(request)));
+    function toStepBlock(uint target, uint resources, bytes memory request) internal pure returns (bytes memory) {
+        return createBlock(Keys.Step, bytes.concat(bytes32(target), bytes32(resources), toBytesBlock(request)));
     }
 
     /// @notice Encode a CALL block.
     /// @param target Target node identifier.
-    /// @param value Native value forwarded with the call.
+    /// @param resources Chain resources assigned to the call.
     /// @param data Raw calldata payload for the target.
     /// @return Encoded CALL block bytes.
-    function toCallBlock(uint target, uint value, bytes memory data) internal pure returns (bytes memory) {
-        return createBlock(Keys.Call, bytes.concat(bytes32(target), bytes32(value), toBytesBlock(data)));
+    function toCallBlock(uint target, uint resources, bytes memory data) internal pure returns (bytes memory) {
+        return createBlock(Keys.Call, bytes.concat(bytes32(target), bytes32(resources), toBytesBlock(data)));
     }
 
     /// @notice Encode a CONTEXT block.
@@ -548,37 +555,37 @@ library Cursors {
     }
 
     /// @notice Encode a PIPE block.
-    /// @param value Native value assigned to the pipe.
+    /// @param resources Chain resources assigned to the pipe.
     /// @param account Command account identifier.
     /// @param state Embedded state block stream.
     /// @param steps Embedded step block stream.
     /// @return Encoded PIPE block bytes.
     function toPipeBlock(
-        uint value,
+        uint resources,
         bytes32 account,
         bytes memory state,
         bytes memory steps
     ) internal pure returns (bytes memory) {
-        return createBlock(Keys.Pipe, bytes.concat(bytes32(value), toContextBlock(account, state, steps)));
-    }
-
-    /// @notice Encode a RELAY block.
-    /// @param chain Destination chain node ID.
-    /// @param resources Chain-adapter-specific resources for the destination pipe.
-    /// @param steps Nested step block stream.
-    /// @return Encoded RELAY block bytes.
-    function toRelayBlock(uint chain, uint resources, bytes memory steps) internal pure returns (bytes memory) {
-        return createBlock(Keys.Relay, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(steps)));
-    }
-
-    /// @notice Encode a DISPATCH block.
-    /// @param chain Destination chain node ID.
-    /// @param resources Chain-adapter-specific resources for the destination dispatch.
-    /// @param payload Encoded cross-chain payload.
-    /// @return Encoded DISPATCH block bytes.
-    function toDispatchBlock(uint chain, uint resources, bytes memory payload) internal pure returns (bytes memory) {
-        return createBlock(Keys.Dispatch, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(payload)));
-    }
+        return createBlock(Keys.Pipe, bytes.concat(bytes32(resources), toContextBlock(account, state, steps)));
+    }
+
+    /// @notice Encode a RELAY block.
+    /// @param chain Destination chain node ID.
+    /// @param resources Chain-adapter-specific resources for the destination pipe.
+    /// @param steps Nested step block stream.
+    /// @return Encoded RELAY block bytes.
+    function toRelayBlock(uint chain, uint resources, bytes memory steps) internal pure returns (bytes memory) {
+        return createBlock(Keys.Relay, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(steps)));
+    }
+
+    /// @notice Encode a DISPATCH block.
+    /// @param chain Destination chain node ID.
+    /// @param resources Chain-adapter-specific resources for the destination dispatch.
+    /// @param payload Encoded cross-chain payload.
+    /// @return Encoded DISPATCH block bytes.
+    function toDispatchBlock(uint chain, uint resources, bytes memory payload) internal pure returns (bytes memory) {
+        return createBlock(Keys.Dispatch, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(payload)));
+    }
 
     // -------------------------------------------------------------------------
     // Raw calldata loaders
@@ -590,31 +597,43 @@ library Cursors {
     /// @param cur Cursor whose current position is advanced by `n` bytes.
     /// @param n Number of bytes to advance.
     /// @return value Loaded word.
-    function read(Cur memory cur, uint n) internal pure returns (bytes32 value) {
-        uint abs = cur.offset + cur.i;
-        assembly ("memory-safe") {
-            value := calldataload(abs)
-        }
-        cur.i += n;
-    }
-
-    /// @notice Read the next 4 bytes from the cursor and advance by 4 bytes.
-    /// @dev Performs no bounds, key, length, or cursor checks.
-    /// @param cur Cursor whose current position is advanced by 4 bytes.
-    /// @return value Loaded bytes4 value.
-    function read4(Cur memory cur) internal pure returns (bytes4 value) {
-        uint abs = cur.offset + cur.i;
-        assembly ("memory-safe") {
-            value := calldataload(abs)
-        }
-        cur.i += 4;
-    }
-
-    /// @notice Read the next 16 bytes from the cursor and advance by 16 bytes.
-    /// @dev Performs no bounds, key, length, or cursor checks.
-    /// @param cur Cursor whose current position is advanced by 16 bytes.
-    /// @return value Loaded bytes16 value.
-    function read16(Cur memory cur) internal pure returns (bytes16 value) {
+    function read(Cur memory cur, uint n) internal pure returns (bytes32 value) {
+        uint abs = cur.offset + cur.i;
+        assembly ("memory-safe") {
+            value := calldataload(abs)
+        }
+        cur.i += n;
+    }
+
+    /// @notice Read the next 4 bytes from the cursor and advance by 4 bytes.
+    /// @dev Performs no bounds, key, length, or cursor checks.
+    /// @param cur Cursor whose current position is advanced by 4 bytes.
+    /// @return value Loaded bytes4 value.
+    function read4(Cur memory cur) internal pure returns (bytes4 value) {
+        uint abs = cur.offset + cur.i;
+        assembly ("memory-safe") {
+            value := calldataload(abs)
+        }
+        cur.i += 4;
+    }
+
+    /// @notice Read the next 8 bytes from the cursor and advance by 8 bytes.
+    /// @dev Performs no bounds, key, length, or cursor checks.
+    /// @param cur Cursor whose current position is advanced by 8 bytes.
+    /// @return value Loaded bytes8 value.
+    function read8(Cur memory cur) internal pure returns (bytes8 value) {
+        uint abs = cur.offset + cur.i;
+        assembly ("memory-safe") {
+            value := calldataload(abs)
+        }
+        cur.i += 8;
+    }
+
+    /// @notice Read the next 16 bytes from the cursor and advance by 16 bytes.
+    /// @dev Performs no bounds, key, length, or cursor checks.
+    /// @param cur Cursor whose current position is advanced by 16 bytes.
+    /// @return value Loaded bytes16 value.
+    function read16(Cur memory cur) internal pure returns (bytes16 value) {
         uint abs = cur.offset + cur.i;
         assembly ("memory-safe") {
             value := calldataload(abs)
@@ -626,30 +645,30 @@ library Cursors {
     /// @dev Performs no bounds, key, length, or cursor checks.
     /// @param cur Cursor whose current position is advanced by 32 bytes.
     /// @return value Loaded word.
-    function read32(Cur memory cur) internal pure returns (bytes32 value) {
-        uint abs = cur.offset + cur.i;
-        assembly ("memory-safe") {
-            value := calldataload(abs)
-        }
-        cur.i += 32;
-    }
-
-    /// @notice Read the next uint from the cursor and advance by one word.
-    /// @dev Performs no bounds, key, length, or cursor checks.
-    /// @param cur Cursor whose current position is advanced by 32 bytes.
-    /// @return value Loaded uint value.
-    function readUint(Cur memory cur) internal pure returns (uint value) {
-        uint abs = cur.offset + cur.i;
-        assembly ("memory-safe") {
-            value := calldataload(abs)
-        }
-        cur.i += 32;
-    }
-
-    /// @notice Read the next two 32-byte words from the cursor and advance by 64 bytes.
-    /// @dev Performs no bounds, key, length, or cursor checks.
-    /// @param cur Cursor whose current position is advanced by 64 bytes.
-    /// @return a First loaded word.
+    function read32(Cur memory cur) internal pure returns (bytes32 value) {
+        uint abs = cur.offset + cur.i;
+        assembly ("memory-safe") {
+            value := calldataload(abs)
+        }
+        cur.i += 32;
+    }
+
+    /// @notice Read the next uint from the cursor and advance by one word.
+    /// @dev Performs no bounds, key, length, or cursor checks.
+    /// @param cur Cursor whose current position is advanced by 32 bytes.
+    /// @return value Loaded uint value.
+    function readUint(Cur memory cur) internal pure returns (uint value) {
+        uint abs = cur.offset + cur.i;
+        assembly ("memory-safe") {
+            value := calldataload(abs)
+        }
+        cur.i += 32;
+    }
+
+    /// @notice Read the next two 32-byte words from the cursor and advance by 64 bytes.
+    /// @dev Performs no bounds, key, length, or cursor checks.
+    /// @param cur Cursor whose current position is advanced by 64 bytes.
+    /// @return a First loaded word.
     /// @return b Second loaded word.
     function read64(Cur memory cur) internal pure returns (bytes32 a, bytes32 b) {
         uint abs = cur.offset + cur.i;
@@ -708,6 +727,26 @@ library Cursors {
         return unpackRaw(cur, Keys.Bytes);
     }
 
+    /// @notice Consume a reserved STRING block and return its UTF-8 payload.
+    /// @param cur Cursor; advanced past the STRING block.
+    /// @return data Decoded STRING payload.
+    function unpackString(Cur memory cur) internal pure returns (string memory data) {
+        return string(unpackRaw(cur, Keys.String));
+    }
+
+    /// @notice Consume a LABEL block and return its fields.
+    /// @param cur Cursor; advanced past the LABEL block.
+    /// @return id Node ID being labelled.
+    /// @return namespace Label namespace.
+    /// @return name Label value.
+    function unpackLabel(Cur memory cur) internal pure returns (uint id, bytes32 namespace, string memory name) {
+        uint end = cur.enter(Keys.Label, 64 + Sizes.Header, 0);
+        id = cur.readUint();
+        namespace = cur.read32();
+        name = cur.unpackString();
+        cur.exit(end);
+    }
+
     /// @notice Consume a dynamic block with a single bytes32 payload.
     /// @param cur Cursor; advanced past the block.
     /// @param key Expected dynamic block key.
@@ -1079,12 +1118,12 @@ library Cursors {
     /// The `req` slice is the raw payload of the block's required BYTES child.
     /// @param cur Cursor; advanced past the block.
     /// @return target Destination node ID for the sub-command.
-    /// @return value Native value to forward with the call.
+    /// @return resources Chain resources assigned to the step.
     /// @return req Embedded request bytes for the sub-command.
-    function unpackStep(Cur memory cur) internal pure returns (uint target, uint value, bytes calldata req) {
+    function unpackStep(Cur memory cur) internal pure returns (uint target, uint resources, bytes calldata req) {
         uint end = cur.enter(Keys.Step, 64 + Sizes.Header, 0);
         target = uint(cur.read32());
-        value = uint(cur.read32());
+        resources = uint(cur.read32());
         req = cur.unpackBytes();
         cur.exit(end);
     }
@@ -1093,12 +1132,12 @@ library Cursors {
     /// The `data` slice is the raw payload of the block's required BYTES child.
     /// @param cur Cursor; advanced past the block.
     /// @return target Target node ID to call.
-    /// @return value Native value to forward with the call.
+    /// @return resources Chain resources assigned to the call.
     /// @return data Raw calldata payload for the target.
-    function unpackCall(Cur memory cur) internal pure returns (uint target, uint value, bytes calldata data) {
+    function unpackCall(Cur memory cur) internal pure returns (uint target, uint resources, bytes calldata data) {
         uint end = cur.enter(Keys.Call, 64 + Sizes.Header, 0);
         target = uint(cur.read32());
-        value = uint(cur.read32());
+        resources = uint(cur.read32());
         data = cur.unpackBytes();
         cur.exit(end);
     }
@@ -1119,50 +1158,50 @@ library Cursors {
         cur.exit(end);
     }
 
-    /// @notice Consume a PIPE block and return its value and context fields.
+    /// @notice Consume a PIPE block and return its resources and context fields.
     /// @param cur Cursor; advanced past the block.
-    /// @return value Native value assigned to the pipe.
+    /// @return resources Chain resources assigned to the pipe.
     /// @return account Command account identifier.
     /// @return state Embedded state block stream.
     /// @return steps Embedded step block stream.
     function unpackPipe(
         Cur memory cur
-    ) internal pure returns (uint value, bytes32 account, bytes calldata state, bytes calldata steps) {
+    ) internal pure returns (uint resources, bytes32 account, bytes calldata state, bytes calldata steps) {
         uint end = cur.enter(Keys.Pipe, 32 + Sizes.Header + 32 + 2 * Sizes.Header, 0);
-        value = uint(cur.read32());
+        resources = uint(cur.read32());
         (account, state, steps) = cur.unpackContext();
         cur.exit(end);
     }
 
-    /// @notice Consume a RELAY block and return its destination chain, resources, and step stream.
-    /// @param cur Cursor; advanced past the block.
-    /// @return chain Destination chain node ID.
-    /// @return resources Chain-adapter-specific resources for the destination pipe.
-    /// @return steps Embedded step block stream.
-    function unpackRelay(
-        Cur memory cur
-    ) internal pure returns (uint chain, uint resources, bytes calldata steps) {
-        uint end = cur.enter(Keys.Relay, 64 + Sizes.Header, 0);
-        chain = cur.readUint();
-        resources = cur.readUint();
-        steps = cur.unpackBytes();
-        cur.exit(end);
-    }
-
-    /// @notice Consume a DISPATCH block and return its destination chain, resources, and payload.
-    /// @param cur Cursor; advanced past the block.
-    /// @return chain Destination chain node ID.
-    /// @return resources Chain-adapter-specific resources for the destination dispatch.
-    /// @return payload Encoded cross-chain payload.
-    function unpackDispatch(
-        Cur memory cur
-    ) internal pure returns (uint chain, uint resources, bytes calldata payload) {
-        uint end = cur.enter(Keys.Dispatch, 64 + Sizes.Header, 0);
-        chain = cur.readUint();
-        resources = cur.readUint();
-        payload = cur.unpackBytes();
-        cur.exit(end);
-    }
+    /// @notice Consume a RELAY block and return its destination chain, resources, and step stream.
+    /// @param cur Cursor; advanced past the block.
+    /// @return chain Destination chain node ID.
+    /// @return resources Chain-adapter-specific resources for the destination pipe.
+    /// @return steps Embedded step block stream.
+    function unpackRelay(
+        Cur memory cur
+    ) internal pure returns (uint chain, uint resources, bytes calldata steps) {
+        uint end = cur.enter(Keys.Relay, 64 + Sizes.Header, 0);
+        chain = cur.readUint();
+        resources = cur.readUint();
+        steps = cur.unpackBytes();
+        cur.exit(end);
+    }
+
+    /// @notice Consume a DISPATCH block and return its destination chain, resources, and payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return chain Destination chain node ID.
+    /// @return resources Chain-adapter-specific resources for the destination dispatch.
+    /// @return payload Encoded cross-chain payload.
+    function unpackDispatch(
+        Cur memory cur
+    ) internal pure returns (uint chain, uint resources, bytes calldata payload) {
+        uint end = cur.enter(Keys.Dispatch, 64 + Sizes.Header, 0);
+        chain = cur.readUint();
+        resources = cur.readUint();
+        payload = cur.unpackBytes();
+        cur.exit(end);
+    }
 
     // Type-specific validators
 
@@ -1385,6 +1424,27 @@ library Cursors {
         if (uint(bytes32(msg.data[abs + 128:abs + 160])) < amount) revert UnexpectedValue();
     }
 
+    // -------------------------------------------------------------------------
+    // Transform helpers
+    // -------------------------------------------------------------------------
+
+    /// @notice Consume a RELAY block and encode its destination pipe payload.
+    /// @param cur Cursor; advanced past the RELAY block.
+    /// @param account Account identifier to embed in the destination pipe context.
+    /// @param state State block stream to embed in the destination pipe context.
+    /// @return chain Destination chain node ID.
+    /// @return resources Chain resources assigned to the destination pipe.
+    /// @return pipe Encoded PIPE block containing `account`, `state`, and relay steps.
+    function relayToPipe(
+        Cur memory cur,
+        bytes32 account,
+        bytes calldata state
+    ) internal pure returns (uint chain, uint resources, bytes memory pipe) {
+        bytes calldata steps;
+        (chain, resources, steps) = cur.unpackRelay();
+        pipe = toPipeBlock(resources, account, bytes(state), bytes(steps));
+    }
+
     // -------------------------------------------------------------------------
     // Search helpers
     // -------------------------------------------------------------------------

package/blocks/Keys.sol

@@ -33,21 +33,23 @@ library Keys {
     bytes4 constant Evm = bytes4(keccak256("#evm"));
     /// @dev Reserved raw bytes child block.
     bytes4 constant Bytes = bytes4(keccak256("#bytes"));
+    /// @dev Reserved UTF-8 string child block.
+    bytes4 constant String = bytes4(keccak256("#string"));
     /// @dev Account identifier - (bytes32 account)
     bytes4 constant Account = bytes4(keccak256("#account"));
     /// @dev Transfer record passed through the pipeline - (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)
     bytes4 constant Transaction = bytes4(keccak256("#transaction"));
-    /// @dev Sub-command invocation - (uint target, uint value, #bytes as request)
+    /// @dev Sub-command invocation - (uint target, uint resources, #bytes as request)
     bytes4 constant Step = bytes4(keccak256("#step"));
-    /// @dev Cross-chain pipe relay - (uint chain, uint resources, #bytes as steps)
-    bytes4 constant Relay = bytes4(keccak256("#relay"));
-    /// @dev Cross-chain encoded payload dispatch - (uint chain, uint resources, #bytes as payload)
-    bytes4 constant Dispatch = bytes4(keccak256("#dispatch"));
-    /// @dev Raw external call - (uint target, uint value, #bytes as payload)
+    /// @dev Cross-chain pipe relay - (uint chain, uint resources, #bytes as steps)
+    bytes4 constant Relay = bytes4(keccak256("#relay"));
+    /// @dev Cross-chain encoded payload dispatch - (uint chain, uint resources, #bytes as payload)
+    bytes4 constant Dispatch = bytes4(keccak256("#dispatch"));
+    /// @dev Raw external call - (uint target, uint resources, #bytes as payload)
     bytes4 constant Call = bytes4(keccak256("#call"));
     /// @dev Command context transport - (bytes32 account, #bytes as state, #bytes as request)
     bytes4 constant Context = bytes4(keccak256("#context"));
-    /// @dev Pipeline invocation - (uint value, #context)
+    /// @dev Pipeline invocation - (uint resources, #context)
     bytes4 constant Pipe = bytes4(keccak256("#pipe"));
     /// @dev Authentication proof - (uint cid, uint deadline, #bytes as proof); must appear last in its segment
     bytes4 constant Auth = bytes4(keccak256("#auth"));
@@ -57,6 +59,8 @@ library Keys {
     bytes4 constant Node = bytes4(keccak256("#node"));
     /// @dev Relayer bounty - (uint amount, bytes32 relayer)
     bytes4 constant Bounty = bytes4(keccak256("#bounty"));
+    /// @dev Mutable node label - (uint id, bytes32 namespace, #string as name)
+    bytes4 constant Label = bytes4(keccak256("#label"));
 
     /// @dev Structural status form - (uint code)
     bytes4 constant Status = bytes4(keccak256("#status"));

package/blocks/Schema.sol

@@ -18,10 +18,14 @@ pragma solidity ^0.8.33;
 // - run items may repeat at top level for batching
 // - `maybe #x { ... }` marks an optional block item
 // - `many #x { ... }` emits one generic list block containing repeated `#x` items
+// - `resources` fields are chain-specific resource words; one chain type may
+//   pack them differently from another, but a given chain type must use one
+//   stable format everywhere. EVM resources use the low 128 bits as native value.
 // - fixed fields are packed in declaration order
 // - blocks have fixed fields followed by a dynamic child-block tail
 // - child block tails are embedded directly, without an extra stream wrapper
 // - `#bytes` is a reserved child block that stores raw bytes and has no body
+// - `#string` is a reserved child block that stores UTF-8 string bytes and has no body
 // - generic `#data` uses the stable key derived from `#data`
 // - generic lists use the stable key derived from `#list`
 // - keys are derived from block names, e.g. bytes4(keccak256("#amount"))
@@ -62,15 +66,17 @@ library Schemas {
     string constant Allowance = "#allowance { uint host, bytes32 asset, bytes32 meta, uint amount }";
     string constant Transaction = "#transaction { bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount }";
     string constant Context = "#context { bytes32 account, #bytes as state, #bytes as request }";
-    string constant Pipe = "#pipe { uint value, #context { bytes32 account, #bytes as state, #bytes as steps } }";
-    string constant Call = "#call { uint target, uint value, #bytes as payload }";
-    string constant Step = "#step { uint target, uint value, #bytes as request }";
-    string constant Relay = "#relay { uint chain, uint resources, #bytes as steps }";
-    string constant Dispatch = "#dispatch { uint chain, uint resources, #bytes as payload }";
+    string constant Pipe = "#pipe { uint resources, #context { bytes32 account, #bytes as state, #bytes as steps } }";
+    string constant Call = "#call { uint target, uint resources, #bytes as payload }";
+    string constant Step = "#step { uint target, uint resources, #bytes as request }";
+    string constant Relay = "#relay { uint chain, uint resources, #bytes as steps }";
+    string constant Dispatch = "#dispatch { uint chain, uint resources, #bytes as payload }";
     string constant Bounty = "#bounty { uint amount, bytes32 relayer }";
     string constant Fee = "#fee { uint amount }";
     string constant Auth = "#auth { uint cid, uint deadline, #bytes as proof }";
+    string constant Label = "#label { uint id, bytes32 namespace, #string as name }";
     string constant Bytes = "#bytes";
+    string constant String = "#string";
     string constant Data = "#data";
     string constant List = "#list";
     string constant Evm = "#evm";

package/blocks/Writers.sol

@@ -24,6 +24,7 @@ struct Writer {
 library Hints {
     uint constant Any = 128;
     uint constant Bytes = 128;
+    uint constant String = 128;
     uint constant Step = 256;
     uint constant Call = 256;
     uint constant Context = 512;
@@ -116,6 +117,14 @@ library Writers {
         return allocFromHint(count, Hints.Bytes);
     }
 
+    /// @notice Allocate a writer for `count` STRING blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded string blocks exceed the initial hint.
+    /// @param count Number of string blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocStrings(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.String);
+    }
+
     /// @notice Allocate a writer sized for exactly `count` 32-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
@@ -862,22 +871,29 @@ library Writers {
         appendBlock(writer, Keys.Bytes, data);
     }
 
+    /// @notice Append a STRING block.
+    /// @param writer Destination writer; `i` is advanced by the encoded STRING block length.
+    /// @param data String payload.
+    function appendString(Writer memory writer, string memory data) internal pure {
+        appendBlock(writer, Keys.String, bytes(data));
+    }
+
     /// @notice Append a STEP block with a nested request BYTES payload.
     /// @param writer Destination writer; `i` is advanced by the encoded STEP block length.
     /// @param target Command target identifier.
-    /// @param value Native value forwarded with the step.
+    /// @param resources Chain resources assigned to the step.
     /// @param request Raw nested request payload.
-    function appendStep(Writer memory writer, uint target, uint value, bytes memory request) internal pure {
-        appendBlock64Bytes(writer, Keys.Step, bytes32(target), bytes32(value), request);
+    function appendStep(Writer memory writer, uint target, uint resources, bytes memory request) internal pure {
+        appendBlock64Bytes(writer, Keys.Step, bytes32(target), bytes32(resources), request);
     }
 
     /// @notice Append a CALL block with a nested payload BYTES block.
     /// @param writer Destination writer; `i` is advanced by the encoded CALL block length.
     /// @param target Call target identifier.
-    /// @param value Native value forwarded with the call.
+    /// @param resources Chain resources assigned to the call.
     /// @param data Raw nested call payload.
-    function appendCall(Writer memory writer, uint target, uint value, bytes memory data) internal pure {
-        appendBlock64Bytes(writer, Keys.Call, bytes32(target), bytes32(value), data);
+    function appendCall(Writer memory writer, uint target, uint resources, bytes memory data) internal pure {
+        appendBlock64Bytes(writer, Keys.Call, bytes32(target), bytes32(resources), data);
     }
 
     /// @notice Append a CONTEXT block with nested state/request BYTES payloads.
@@ -891,13 +907,13 @@ library Writers {
 
     /// @notice Append a PIPE block with a nested CONTEXT block.
     /// @param writer Destination writer; `i` is advanced by the encoded PIPE block length.
-    /// @param value Native value assigned to the pipe.
+    /// @param resources Chain resources assigned to the pipe.
     /// @param account Command account identifier.
     /// @param state Raw nested state payload.
     /// @param steps Raw nested step payload.
     function appendPipe(
         Writer memory writer,
-        uint value,
+        uint resources,
         bytes32 account,
         bytes memory state,
         bytes memory steps
@@ -909,7 +925,7 @@ library Writers {
 
         uint p = writeHeader(writer.dst, i, Keys.Pipe, uint32(max32(len)));
         assembly ("memory-safe") {
-            mstore(add(p, 0x08), value)
+            mstore(add(p, 0x08), resources)
         }
 
         writeBlock32BytesBytes(writer.dst, i + Sizes.Header + 32, Keys.Context, account, state, steps);