@agenticprimitives/contracts 1.0.0-alpha.25 → 1.0.0-alpha.27

package/src/custody/TreasurySpendPolicy.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/**
+ * @title TreasurySpendPolicy — an aggregate ceiling AT THE RESOURCE (spec 410 §7, THESIS-6)
+ * @notice Every caveat enforcer bounds ONE delegation: `ValueEnforcer` a call's value, `PaymentEnforcer` a
+ *         mandate's budget under (delegator, delegationHash). None of them can see the treasury's other
+ *         delegates, so two delegates each under their own ceiling can jointly exceed the principal's
+ *         budget. This module is the ceiling that belongs to the TREASURY: an ERC-7579 HOOK the account
+ *         installs, consulted on every `execute` / `executeBatch` — a custodian's own userOp and a delegated
+ *         redemption alike, because the account runs its hooks on both — that adds the value each call moves
+ *         to the current window and refuses the one that would pass the ceiling.
+ *
+ *         WHAT IT COUNTS. Native value (`value` on the call) when `asset == address(0)`; otherwise ERC-20
+ *         `transfer(to, amount)` and `transferFrom(from, to, amount)` calldata aimed at `asset`. Anything else
+ *         moves no value of this asset and is not counted. A batch is one call: its inner calls are summed.
+ *
+ *         WINDOWS are fixed-length epochs from `windowStart` — never sliding — so the check is O(1) and the
+ *         refusal is reproducible off chain from the receipt and the block time.
+ *
+ *         WHO SETS IT. The budget is the install data: `installModule(4, this, abi.encode(asset, ceiling,
+ *         windowSeconds))`, which on a custody-governed treasury is a governance selector under its quorum;
+ *         changing it is an uninstall + reinstall under the same gate. There is no setter a single key could
+ *         reach. Per-delegation ceilings are untouched: the tighter of the two refuses.
+ *
+ *         WHAT IT IS NOT: a policy of who may spend (that is the mandate), a rate limit on calls, or anything
+ *         a planner consults — the harness may READ `budget()` to say "this would exceed the treasury's
+ *         shared budget" before a signature (honesty); the hook is the authority.
+ */
+contract TreasurySpendPolicy {
+    struct Budget {
+        address asset;        // address(0) = native value
+        uint256 ceiling;      // per window, in the asset's base units
+        uint64 windowSeconds; // fixed epochs from windowStart
+        uint64 windowStart;
+        uint64 windowIndex;   // the epoch `spent` belongs to
+        uint256 spent;
+        bool installed;
+    }
+
+    /// account => budget
+    mapping(address => Budget) private _budgets;
+
+    event BudgetInstalled(address indexed account, address indexed asset, uint256 ceiling, uint64 windowSeconds, uint64 windowStart);
+    event BudgetUninstalled(address indexed account);
+    event Spent(address indexed account, uint64 indexed windowIndex, uint256 amount, uint256 spentInWindow);
+
+    error BudgetExceeded(uint256 ceiling, uint256 spentInWindow, uint256 amount);
+    error NotInstalledOn(address account);
+    error AlreadyInstalledOn(address account);
+    error BadBudget();
+
+    bytes4 private constant TRANSFER = bytes4(keccak256("transfer(address,uint256)"));
+    bytes4 private constant TRANSFER_FROM = bytes4(keccak256("transferFrom(address,address,uint256)"));
+
+    // ─── ERC-7579 module surface ───────────────────────────────────────
+
+    function isModuleType(uint256 moduleTypeId) external pure returns (bool) { return moduleTypeId == 4; }
+    function moduleId() external pure returns (string memory) { return "agenticprimitives-treasury-spend-policy-1"; }
+
+    /// @notice Called by the account from `installModule` (governance-gated there): the budget is the install data.
+    function onInstall(bytes calldata initData) external {
+        Budget storage b = _budgets[msg.sender];
+        if (b.installed) revert AlreadyInstalledOn(msg.sender);
+        (address asset, uint256 ceiling, uint64 windowSeconds) = abi.decode(initData, (address, uint256, uint64));
+        if (windowSeconds == 0) revert BadBudget();
+        b.asset = asset;
+        b.ceiling = ceiling;
+        b.windowSeconds = windowSeconds;
+        b.windowStart = uint64(block.timestamp);
+        b.windowIndex = 0;
+        b.spent = 0;
+        b.installed = true;
+        emit BudgetInstalled(msg.sender, asset, ceiling, windowSeconds, b.windowStart);
+    }
+
+    function onUninstall(bytes calldata) external {
+        if (!_budgets[msg.sender].installed) revert NotInstalledOn(msg.sender);
+        delete _budgets[msg.sender];
+        emit BudgetUninstalled(msg.sender);
+    }
+
+    // ─── The hook ──────────────────────────────────────────────────────
+
+    /// @notice `preCheck` from the account: `msgData` is `abi.encode(target, value, data)` for `execute` and
+    ///         `abi.encode(Call[])` for `executeBatch`. Sums the value this call moves in the budget's asset and
+    ///         refuses when the window's total would pass the ceiling.
+    function preCheck(address, uint256, bytes calldata msgData) external returns (bytes memory) {
+        Budget storage b = _budgets[msg.sender];
+        if (!b.installed) return hex"";
+        uint256 amount = _valueMoved(b.asset, msgData);
+        if (amount == 0) return hex"";
+        uint64 idx = uint64((block.timestamp - b.windowStart) / b.windowSeconds);
+        if (idx != b.windowIndex) { b.windowIndex = idx; b.spent = 0; }
+        uint256 next = b.spent + amount;
+        if (next > b.ceiling) revert BudgetExceeded(b.ceiling, b.spent, amount);
+        b.spent = next;
+        emit Spent(msg.sender, idx, amount, next);
+        return hex"";
+    }
+
+    function postCheck(bytes calldata) external {}
+
+    // ─── Reads (the harness's honesty, never its authority) ────────────
+
+    function budget(address account) external view returns (address asset, uint256 ceiling, uint64 windowSeconds, uint64 windowStart, uint64 windowIndex, uint256 spent, bool installed) {
+        Budget storage b = _budgets[account];
+        return (b.asset, b.ceiling, b.windowSeconds, b.windowStart, b.windowIndex, b.spent, b.installed);
+    }
+
+    /// @notice What the account has spent in the CURRENT window (0 once the window rolled), and the ceiling.
+    function remaining(address account) external view returns (uint256 left, uint256 ceiling) {
+        Budget storage b = _budgets[account];
+        if (!b.installed) return (type(uint256).max, 0);
+        uint64 idx = uint64((block.timestamp - b.windowStart) / b.windowSeconds);
+        uint256 spent = idx == b.windowIndex ? b.spent : 0;
+        return (b.ceiling > spent ? b.ceiling - spent : 0, b.ceiling);
+    }
+
+    // ─── Internals ─────────────────────────────────────────────────────
+
+    /// @dev Both encodings the account uses, told apart by the first word: `abi.encode(Call[])` opens with the
+    ///      array's offset (exactly 0x20), `abi.encode(target, value, data)` with the target address — and no
+    ///      contract lives at address 0x20. The decode runs through an external self-call so a malformed payload
+    ///      is caught rather than reverting the account's call (abi.decode cannot be tried in place).
+    function _valueMoved(address asset, bytes calldata msgData) internal view returns (uint256 total) {
+        if (msgData.length < 32) return 0;
+        uint256 first = uint256(bytes32(msgData[0:32]));
+        if (first == 0x20) {
+            try this.decodeBatch(msgData) returns (Call[] memory calls) {
+                for (uint256 i = 0; i < calls.length; i++) total += _amountOf(asset, calls[i].target, calls[i].value, calls[i].data);
+                return total;
+            } catch { return 0; }
+        }
+        try this.decodeSingle(msgData) returns (address target, uint256 value, bytes memory data) {
+            return _amountOf(asset, target, value, data);
+        } catch { return 0; }
+    }
+
+    struct Call { address target; uint256 value; bytes data; }
+
+    function decodeSingle(bytes calldata msgData) external pure returns (address, uint256, bytes memory) {
+        return abi.decode(msgData, (address, uint256, bytes));
+    }
+    function decodeBatch(bytes calldata msgData) external pure returns (Call[] memory) {
+        return abi.decode(msgData, (Call[]));
+    }
+
+    function _amountOf(address asset, address target, uint256 value, bytes memory data) internal pure returns (uint256) {
+        if (asset == address(0)) return value;
+        if (target != asset || data.length < 4) return 0;
+        bytes4 sel;
+        assembly { sel := mload(add(data, 32)) }
+        if (sel == TRANSFER && data.length >= 68) {
+            uint256 amount;
+            assembly { amount := mload(add(data, 68)) }
+            return amount;
+        }
+        if (sel == TRANSFER_FROM && data.length >= 100) {
+            uint256 amount;
+            assembly { amount := mload(add(data, 100)) }
+            return amount;
+        }
+        return 0;
+    }
+}

package/src/enforcers/DigestBindingEnforcer.sol

@@ -10,14 +10,15 @@ import "../agency/ICaveatEnforcer.sol";
  *         §2): authority *for a reason*, not authority for any purpose until revoked.
  *
  * @dev terms = abi.encode(bytes32 kind, bytes32 digest)
- *      args  = abi.encode(bytes32 presented)          — supplied by the redeemer at redemption
+ *      args  = abi.encode(bytes32 presented, bytes32 stepNonce)   — supplied by the redeemer at redemption
  *
  *      `kind` names WHICH artifact the digest is of, so an off-chain reader can tell an intent binding
  *      from a projection binding without guessing:
  *          keccak256("ap:intent")      — the canonical intent (RFC 8785 JCS bytes)
  *          keccak256("ap:projection")  — what was disclosed to the grantee (spec 336 §4)
  *          keccak256("ap:offer")       — the accepted offer (spec 336 §5)
- *      One enforcer serves all three: the mechanics are identical and the kind belongs in the terms,
+ *          keccak256("ap:plan")        — the admitted plan (spec 408 §2.3)
+ *      One enforcer serves all four: the mechanics are identical and the kind belongs in the terms,
  *      where it is signed, rather than in which contract address was chosen.
  *
  *      WHAT THIS ENFORCES, HONESTLY. The chain cannot know what an intent *means*; it can only hold
@@ -30,33 +31,67 @@ import "../agency/ICaveatEnforcer.sol";
  *        2. the presented digest lands in the transaction, so the receipt's `intentDigest` and the
  *           chain's record of what the redeemer claimed to be doing are the same bytes — evidence a
  *           third party can check without trusting either side.
- *      A redeemer that copies `terms` into `args` satisfies the check; that is the point — it has
+ *      A redeemer that copies `terms` into `args` satisfies the digest check; that is the point — it has
  *      now committed, on chain, to that intent, and a step whose real intent differs is caught by the
  *      verifier that computed the digest from the step rather than from the caveat.
  *
- *      R6.7 — Stateless validator: hooks are `pure`, zero storage; the DM-side pause check gates all
- *      reachable enforcer dispatch.
+ *      R917-C-4 (spec 408 §1.4) — SINGLE-USE PER STEP. A digest-bound redemption is consumed under
+ *      `(delegator, delegationHash, kind, stepNonce)`: the harness derives `stepNonce` from the intent
+ *      digest and the step's reference (the same derivation as `PaymentEnforcer`'s nonce), so ONE step
+ *      redeems once and a replay of it reverts `StepNonceReused`. Which steps exist is bound off chain by
+ *      the plan digest the mandate carries; the chain holds each of them to one redemption. The hooks
+ *      therefore mutate state and are `onlyDelegationManager` (EXT-PMT-1's rule for stateful enforcers):
+ *      a stranger cannot burn a step's nonce ahead of the legitimate redemption.
  */
 contract DigestBindingEnforcer is ICaveatEnforcer {
     error BadTermsLength();
     error BadArgsLength();
     error DigestMismatch(bytes32 kind, bytes32 bound, bytes32 presented);
+    error StepNonceReused(bytes32 kind, bytes32 stepNonce);
+    error NotDelegationManager(address caller);
+
+    /// @notice The ONLY authorized caller of `beforeHook` — it consumes a nonce (R917-C-4).
+    address public immutable delegationManager;
+
+    /// delegator => delegationHash => keccak256(kind, stepNonce) => consumed
+    mapping(address => mapping(bytes32 => mapping(bytes32 => bool))) private _used;
+
+    event DigestBindingRedeemed(address indexed delegator, bytes32 indexed delegationHash, bytes32 indexed kind, bytes32 presented, bytes32 stepNonce);
+
+    constructor(address delegationManager_) {
+        require(delegationManager_ != address(0), "DigestBindingEnforcer: zero DelegationManager");
+        delegationManager = delegationManager_;
+    }
+
+    modifier onlyDelegationManager() {
+        if (msg.sender != delegationManager) revert NotDelegationManager(msg.sender);
+        _;
+    }
+
+    /// @notice Whether `stepNonce` was already consumed for this binding (a reader's replay check).
+    function isUsed(address delegator, bytes32 delegationHash, bytes32 kind, bytes32 stepNonce) external view returns (bool) {
+        return _used[delegator][delegationHash][keccak256(abi.encode(kind, stepNonce))];
+    }
 
     function beforeHook(
         bytes calldata terms,
         bytes calldata args,
-        bytes32,
-        address,
+        bytes32 delegationHash,
+        address delegator,
         address,
         address,
         uint256,
         bytes calldata
-    ) external pure override {
+    ) external override onlyDelegationManager {
         if (terms.length != 64) revert BadTermsLength();
-        if (args.length != 32) revert BadArgsLength();
+        if (args.length != 64) revert BadArgsLength();
         (bytes32 kind, bytes32 bound) = abi.decode(terms, (bytes32, bytes32));
-        bytes32 presented = abi.decode(args, (bytes32));
+        (bytes32 presented, bytes32 stepNonce) = abi.decode(args, (bytes32, bytes32));
         if (presented != bound) revert DigestMismatch(kind, bound, presented);
+        bytes32 slot = keccak256(abi.encode(kind, stepNonce));
+        if (_used[delegator][delegationHash][slot]) revert StepNonceReused(kind, stepNonce);
+        _used[delegator][delegationHash][slot] = true;
+        emit DigestBindingRedeemed(delegator, delegationHash, kind, presented, stepNonce);
     }
 
     function afterHook(

package/src/enforcers/PayloadClassesEnforcer.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "../agency/ICaveatEnforcer.sol";
+
+/**
+ * @title PayloadClassesEnforcer — the INFORMATION-FLOW caveat (spec 410 §7)
+ * @notice Where a read precedes a write in one plan — read a member's record, then send a message — the
+ *         mandate names, as ontology classes, what the write MAY CARRY: `apvault:ContactEmail`, never
+ *         `apvault:GivingHistory`. terms = abi.encode(string[] classIris).
+ *
+ *         THE CHAIN CANNOT READ A PAYLOAD, and this enforcer does not pretend to: its hooks are pure no-ops.
+ *         What it does is pin the terms INTO THE SIGNED DELEGATION — the caveat is part of the EIP-712 hash
+ *         the person approved — so the off-chain per-step verifier (`delegation.evaluateCaveats`, strict)
+ *         judges the write's declared payload classes (the tool contract's `carries`, per argument) against
+ *         exactly what was signed, and nobody can widen the list without a new signature. An enforcer that
+ *         judged nothing and pinned nothing would be a comment; this one pins.
+ *
+ *         What it is NOT: authority over the read (the read has its own mandate and scope), a content
+ *         filter, or a substitute for the vault's per-record scope — those are enforced where the data is.
+ */
+contract PayloadClassesEnforcer is ICaveatEnforcer {
+    function beforeHook(bytes calldata, bytes calldata, bytes32, address, address, address, uint256, bytes calldata) external pure override {}
+    function afterHook(bytes calldata, bytes calldata, bytes32, address, address, address, uint256, bytes calldata) external pure override {}
+
+    /// @notice The classes a wire's terms name — for a reader with the wire and no SDK.
+    function classesOf(bytes calldata terms) external pure returns (string[] memory) {
+        return abi.decode(terms, (string[]));
+    }
+}

package/src/provenance/ReceiptAnchorRegistry.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/**
+ * @title ReceiptAnchorRegistry
+ * @notice The on-chain ANCHOR for a harness receipt (spec 351 P0.6, spec 406 W2): a run's record digest, bound
+ *         to the intent digest the mandate was over and the mandate's reference, anchored once by the acting
+ *         runtime's agent. A counterparty who holds the record recomputes its digest and reads the anchor here —
+ *         no trust in the runtime's logs, no vendor, no vault: the chain says a runtime with THIS agent's key
+ *         committed to THESE bytes at THIS block, and the intent digest says which ask it was under.
+ *
+ * @dev    DIGESTS AND ADDRESSES ONLY — nothing of what the run was about reaches the chain (the S1 firewall of
+ *         spec 395 holds by construction). Per-row storage, so a reader uses `readContract` (ADR-0012: no log
+ *         walks in product paths); the event is for indexers. Anchoring is permissionless: WHO anchored is the
+ *         evidence (`anchoredBy`), never a gate — a stranger anchoring random digests proves nothing about a
+ *         run whose receipt names a different agent. A digest anchors ONCE PER ANCHORER (R917-C-3, spec 408
+ *         §1.5): rows are keyed by `(anchoredBy, receiptDigest)`, so a front-runner on a public mempool cannot
+ *         squat the digest ahead of the agent, and an anchor cannot be re-attributed after the fact.
+ */
+contract ReceiptAnchorRegistry {
+    struct Anchor {
+        address anchoredBy;
+        uint64 at;
+        bytes32 intentDigest;
+        bytes32 mandateRef;
+    }
+
+    /// anchoredBy => receiptDigest => anchor (R917-C-3: keyed by WHO anchored, so a stranger's anchor of
+    /// the same digest is a different row — it can neither pre-empt the agent's nor be mistaken for it).
+    mapping(address => mapping(bytes32 => Anchor)) private _anchors;
+
+    event ReceiptAnchored(bytes32 indexed receiptDigest, address indexed anchoredBy, bytes32 indexed intentDigest, bytes32 mandateRef, uint64 at);
+
+    error ZeroDigest();
+    error AlreadyAnchored(bytes32 receiptDigest, address by);
+
+    /// @notice Anchor a receipt digest, once per anchorer. `intentDigest` and `mandateRef` may be zero for a run under no mandate (a read).
+    function anchor(bytes32 receiptDigest, bytes32 intentDigest, bytes32 mandateRef) external {
+        if (receiptDigest == bytes32(0)) revert ZeroDigest();
+        Anchor storage a = _anchors[msg.sender][receiptDigest];
+        if (a.anchoredBy != address(0)) revert AlreadyAnchored(receiptDigest, a.anchoredBy);
+        _anchors[msg.sender][receiptDigest] = Anchor({ anchoredBy: msg.sender, at: uint64(block.timestamp), intentDigest: intentDigest, mandateRef: mandateRef });
+        emit ReceiptAnchored(receiptDigest, msg.sender, intentDigest, mandateRef, uint64(block.timestamp));
+    }
+
+    /// @notice The anchor `anchoredBy` made of a digest, or a zero struct when none — the reader names the
+    ///         agent from the receipt it holds, and decides what absence means.
+    function anchorOf(address anchoredBy, bytes32 receiptDigest) external view returns (Anchor memory) {
+        return _anchors[anchoredBy][receiptDigest];
+    }
+
+    function isAnchored(address anchoredBy, bytes32 receiptDigest) external view returns (bool) {
+        return _anchors[anchoredBy][receiptDigest].anchoredBy != address(0);
+    }
+}

package/src/registry/EstateProjectionRegistry.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/**
+ * @title EstateProjectionRegistry — an estate's authority, projected onto PUBLIC GROUND (spec 410 §4)
+ * @notice One registry, many estates. An estate's grants and relationships are enforced on its own chain and
+ *         held in its principals' vaults; a verifier elsewhere can read neither. What the estate anchors here
+ *         is two Merkle roots over BLINDED commitments — the live-grant root (every grant currently live) and
+ *         the membership root (every countersigned relationship credential) — plus the hash of its signed
+ *         charter (spec 410 §9), under a monotonic sequence. A presentation against these roots tells a
+ *         verifier in another estate that a grant is live or an agent is a member in that estate as of that
+ *         sequence, and nothing else (the estate-projection SDK package).
+ *
+ *         WHO MAY WRITE. An estate REGISTERS once: its id — keccak256("eip155:<chainId>:<governance>"), the
+ *         one fact public ground learns about it — bound to the SIGNER its governance controls here (an EOA
+ *         or an account on this chain). First registration wins; the signer rotates only by the current
+ *         signer. `setRoots` is the signer's, with a sequence strictly above the last: a replayed or reordered
+ *         projection is refused. No admin, no pause, no upgrade: public ground has no operator either.
+ *
+ *         WHAT THIS IS NOT: authority. A root proves what the estate vouches for at a moment; whether the
+ *         receiving estate lets an agent ACT is its own mandate, per step (ADR-0056 / ADR-0057).
+ */
+contract EstateProjectionRegistry {
+    struct Roots {
+        bytes32 liveGrantRoot;
+        bytes32 membershipRoot;
+        bytes32 charterHash;
+        uint64 sequence;
+        uint64 anchoredAt;
+    }
+
+    mapping(bytes32 estateId => address signer) public signerOf;
+    mapping(bytes32 estateId => Roots) private _roots;
+
+    event EstateRegistered(bytes32 indexed estateId, address indexed signer);
+    event EstateSignerRotated(bytes32 indexed estateId, address indexed from, address indexed to);
+    event RootsAnchored(bytes32 indexed estateId, uint64 indexed sequence, bytes32 liveGrantRoot, bytes32 membershipRoot, bytes32 charterHash);
+
+    error AlreadyRegistered(bytes32 estateId);
+    error NotRegistered(bytes32 estateId);
+    error NotTheSigner(bytes32 estateId, address caller);
+    error SequenceNotAbove(uint64 last, uint64 given);
+    error ZeroAddress();
+
+    /// @notice Bind an estate id to the signer its governance controls on this chain. First come, once.
+    function register(bytes32 estateId, address signer) external {
+        if (signer == address(0)) revert ZeroAddress();
+        if (signerOf[estateId] != address(0)) revert AlreadyRegistered(estateId);
+        signerOf[estateId] = signer;
+        emit EstateRegistered(estateId, signer);
+    }
+
+    function rotateSigner(bytes32 estateId, address to) external {
+        if (to == address(0)) revert ZeroAddress();
+        address cur = signerOf[estateId];
+        if (cur == address(0)) revert NotRegistered(estateId);
+        if (msg.sender != cur) revert NotTheSigner(estateId, msg.sender);
+        signerOf[estateId] = to;
+        emit EstateSignerRotated(estateId, cur, to);
+    }
+
+    /// @notice Anchor the estate's roots under `sequence` (strictly above the last). Refreshed on every revocation
+    ///         and membership change; a verifier's freshness policy reads `anchoredAt`.
+    function setRoots(bytes32 estateId, bytes32 liveGrantRoot, bytes32 membershipRoot, bytes32 charterHash, uint64 sequence) external {
+        address cur = signerOf[estateId];
+        if (cur == address(0)) revert NotRegistered(estateId);
+        if (msg.sender != cur) revert NotTheSigner(estateId, msg.sender);
+        Roots storage r = _roots[estateId];
+        if (sequence <= r.sequence) revert SequenceNotAbove(r.sequence, sequence);
+        r.liveGrantRoot = liveGrantRoot;
+        r.membershipRoot = membershipRoot;
+        r.charterHash = charterHash;
+        r.sequence = sequence;
+        r.anchoredAt = uint64(block.timestamp);
+        emit RootsAnchored(estateId, sequence, liveGrantRoot, membershipRoot, charterHash);
+    }
+
+    /// @notice The one read a verifier makes: the roots as anchored, with the sequence and when.
+    function roots(bytes32 estateId) external view returns (bytes32 liveGrantRoot, bytes32 membershipRoot, bytes32 charterHash, uint64 sequence, uint64 anchoredAt) {
+        Roots storage r = _roots[estateId];
+        return (r.liveGrantRoot, r.membershipRoot, r.charterHash, r.sequence, r.anchoredAt);
+    }
+
+    /// @notice keccak256("eip155:<chainId>:<governance>") — the same derivation the SDK's `estateIdOf` uses.
+    function estateIdOf(uint256 chainId, address governance) external pure returns (bytes32) {
+        return keccak256(abi.encodePacked("eip155:", _utoa(chainId), ":", _lowerHex(governance)));
+    }
+
+    function _utoa(uint256 v) private pure returns (string memory) {
+        if (v == 0) return "0";
+        uint256 j = v; uint256 len;
+        while (j != 0) { len++; j /= 10; }
+        bytes memory b = new bytes(len);
+        while (v != 0) { len -= 1; b[len] = bytes1(uint8(48 + v % 10)); v /= 10; }
+        return string(b);
+    }
+    function _lowerHex(address a) private pure returns (string memory) {
+        bytes memory alphabet = "0123456789abcdef";
+        bytes memory s = new bytes(42);
+        s[0] = "0"; s[1] = "x";
+        uint160 v = uint160(a);
+        for (uint256 i = 0; i < 20; i++) {
+            uint8 bt = uint8(v >> (8 * (19 - i)));
+            s[2 + i * 2] = alphabet[bt >> 4];
+            s[3 + i * 2] = alphabet[bt & 0x0f];
+        }
+        return string(s);
+    }
+}

package/deployments-anvil.json

@@ -1 +0,0 @@
-{"agentAccountFactory":"0x139e1D41943ee15dDe4DF876f9d0E7F85e26660A","agentAccountImplementation":"0x2f663C00A026A416802A629fb44490E3F276cF04","agentNameRegistry":"0x9385556B571ab92bf6dC9a0DbD75429Dd4d56F91","agentNameResolver":"0x162700d1613DfEC978032A909DE02643bC55df1A","agentNameUniversalResolver":"0x67aD6EA566BA6B0fC52e97Bc25CE46120fdAc04c","agentProfileResolver":"0xb185E9f6531BA9877741022C92CE858cDCc5760E","agentRelationship":"0x871ACbEabBaf8Bed65c22ba7132beCFaBf8c27B5","agreementRegistry":"0x01E21d7B8c39dc4C764c19b308Bd8b14B1ba139E","allowedMethodsEnforcer":"0xcE0066b1008237625dDDBE4a751827de037E53D2","allowedTargetsEnforcer":"0x7B4f352Cd40114f12e82fC675b5BA8C7582FC513","approvedHashRegistry":"0xD6b040736e948621c5b6E0a494473c47a6113eA8","attestationRegistry":"0x9Fcca440F19c62CDF7f973eB6DDF218B15d4C71D","callDataHashEnforcer":"0x87006e75a5B6bE9D1bbF61AC8Cd84f05D9140589","chainId":31337,"custodyPolicy":"0xFE5f411481565fbF70D8D33D992C78196E014b90","delegationManager":"0x2625760C4A8e8101801D3a48eE64B2bEA42f1E96","deployer":"0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266","entryPoint":"0x3904b8f5b0F49cD206b7d5AABeE5D1F37eE15D8d","geoFeatureRegistry":"0x1343248Cbd4e291C6979e70a138f4c774e902561","mockUsdc":"0xc9952Fc93Fa9bE383ccB39008c786b9f94eAc95d","ontologyTermRegistry":"0x70eE76691Bdd9696552AF8d4fd634b3cF79DD529","paymentEnforcer":"0xC7143d5bA86553C06f5730c8dC9f8187a621A8D4","paymentReceiptRegistry":"0x8fC8CFB7f7362E44E472c690A6e025B80E406458","permissionlessSubregistry":"0xe1708FA6bb2844D5384613ef0846F9Bc1e8eC55E","permissionlessSubregistryDemoAgent":"0xa722bdA6968F50778B973Ae2701e90200C564B49","quorumEnforcer":"0x51C65cd0Cdb1A8A8b79dfc2eE965B1bA0bb8fc89","relationshipTypeRegistry":"0x8e264821AFa98DD104eEcfcfa7FD9f8D8B320adA","shapeRegistry":"0x8B190573374637f144AC8D37375d97fd84cBD3a0","skillDefinitionRegistry":"0x3C1Cb427D20F15563aDa8C249E71db76d7183B6c","smartAgentPaymaster":"0xDde063eBe8E85D666AD99f731B4Dbf8C98F29708","timestampEnforcer":"0xAdE429ba898c34722e722415D722A70a297cE3a2","universalSignatureValidator":"0xD5724171C2b7f0AA717a324626050BD05767e2C6","valueEnforcer":"0x82EdA215Fa92B45a3a76837C65Ab862b6C7564a8"}