@agenticprimitives/contracts 1.0.0-alpha.28 → 1.0.0-alpha.29

package/dist/abi/PricedSubregistry.json

@@ -0,0 +1,869 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "registry",
+        "type": "address",
+        "internalType": "contract AgentNameRegistry"
+      },
+      {
+        "name": "parentNode",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "defaultResolver",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "coin",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "governor_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "feeTreasury_",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "base_",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "multipliersX10_",
+        "type": "uint16[5]",
+        "internalType": "uint16[5]"
+      },
+      {
+        "name": "cap_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "CLAIM_TICKET_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "COIN",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "DEFAULT_RESOLVER",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MIN_LABEL_LENGTH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "PARENT_NODE",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "REGISTRY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract AgentNameRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "base",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "cap",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "claim",
+    "inputs": [
+      {
+        "name": "t",
+        "type": "tuple",
+        "internalType": "struct PricedSubregistry.ClaimTicket",
+        "components": [
+          {
+            "name": "parentNode",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "label",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "payer",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "price",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "domain",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "gateSig",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "childNode",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "claimCount",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "claimedBy",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "eip712Domain",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "fields",
+        "type": "bytes1",
+        "internalType": "bytes1"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "version",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "chainId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "verifyingContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "salt",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "extensions",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "feeTreasury",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "gates",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "governor",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hasClaimed",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "multipliersX10",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "paid",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "paidAt",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint64",
+        "internalType": "uint64"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "priceOf",
+    "inputs": [
+      {
+        "name": "label",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setFeeTreasury",
+    "inputs": [
+      {
+        "name": "feeTreasury_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setGate",
+    "inputs": [
+      {
+        "name": "gate",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setPriceTable",
+    "inputs": [
+      {
+        "name": "base_",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "multipliersX10_",
+        "type": "uint16[5]",
+        "internalType": "uint16[5]"
+      },
+      {
+        "name": "cap_",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "ticketDigest",
+    "inputs": [
+      {
+        "name": "t",
+        "type": "tuple",
+        "internalType": "struct PricedSubregistry.ClaimTicket",
+        "components": [
+          {
+            "name": "parentNode",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "label",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "payer",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "price",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "domain",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transferGovernor",
+    "inputs": [
+      {
+        "name": "newGovernor",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "usedNonce",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "EIP712DomainChanged",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "FeeTreasurySet",
+    "inputs": [
+      {
+        "name": "feeTreasury",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GateSet",
+    "inputs": [
+      {
+        "name": "gate",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GovernorTransferred",
+    "inputs": [
+      {
+        "name": "oldGovernor",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newGovernor",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "NamePurchased",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "payer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "childNode",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "label",
+        "type": "string",
+        "indexed": false,
+        "internalType": "string"
+      },
+      {
+        "name": "price",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "domain",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PriceTableSet",
+    "inputs": [
+      {
+        "name": "base",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "multipliersX10",
+        "type": "uint16[5]",
+        "indexed": false,
+        "internalType": "uint16[5]"
+      },
+      {
+        "name": "cap",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AddressEmptyCode",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "AddressInsufficientBalance",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "AlreadyClaimed",
+    "inputs": [
+      {
+        "name": "existingNode",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureLength",
+    "inputs": [
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureS",
+    "inputs": [
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "EmptyLabel",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "FailedInnerCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidShortString",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "LabelTooShort",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NonceUsed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotAGate",
+    "inputs": [
+      {
+        "name": "signer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotGovernor",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotPayer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "StringTooLong",
+    "inputs": [
+      {
+        "name": "str",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "TicketExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "WrongPrice",
+    "inputs": [
+      {
+        "name": "expected",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "WrongRoot",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroAddress",
+    "inputs": []
+  }
+]

package/dist/abi/index.d.ts

@@ -57,6 +57,7 @@ export declare const PaymentEnforcer: Abi;
 export declare const PaymentEscrow: Abi;
 export declare const PaymentReceiptRegistry: Abi;
 export declare const PermissionlessSubregistry: Abi;
+export declare const PricedSubregistry: Abi;
 export declare const QuorumEnforcer: Abi;
 export declare const ReceiptAnchorRegistry: Abi;
 export declare const RelationshipTypeRegistry: Abi;

package/dist/abi/index.js

@@ -57,6 +57,7 @@ export { default as PaymentEnforcer } from './PaymentEnforcer.json' with { type:
 export { default as PaymentEscrow } from './PaymentEscrow.json' with { type: 'json' };
 export { default as PaymentReceiptRegistry } from './PaymentReceiptRegistry.json' with { type: 'json' };
 export { default as PermissionlessSubregistry } from './PermissionlessSubregistry.json' with { type: 'json' };
+export { default as PricedSubregistry } from './PricedSubregistry.json' with { type: 'json' };
 export { default as QuorumEnforcer } from './QuorumEnforcer.json' with { type: 'json' };
 export { default as ReceiptAnchorRegistry } from './ReceiptAnchorRegistry.json' with { type: 'json' };
 export { default as RelationshipTypeRegistry } from './RelationshipTypeRegistry.json' with { type: 'json' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticprimitives/contracts",
-  "version": "1.0.0-alpha.28",
+  "version": "1.0.0-alpha.29",
   "type": "module",
   "description": "Solidity contracts + ABIs + flattened sources + per-network deployment addresses for the agenticprimitives stack.",
   "homepage": "https://agenticprimitives.dev",

package/src/naming/PricedSubregistry.sol

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "./AgentNameRegistry.sol";
+import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title PricedSubregistry
+ * @notice A subregistry for one typed root where a claim COSTS a coin and needs a ticket (spec 431; the contract
+ *         spec is 432). The successor of `PermissionlessSubregistry` for a root whose names are purchased.
+ *
+ * One signed operation, one receipt:
+ *   - The PAYER calls `claim(ticket, gateSig)`. The payer is a treasury Smart Agent (assets live only in treasuries);
+ *     it approved this contract for the price beforehand, in the same user operation.
+ *   - The TICKET is signed (EIP-712) by an estate's naming GATE — the key a Home holds. A gate signs only after its
+ *     own rules passed (the domain rule: a protected label needs a verified email at that domain). The contract
+ *     checks the signature against the gates the governor named; it stores nothing about why the gate agreed
+ *     beyond `domain` (a label, never an email).
+ *   - The PRICE is a pure function of the label's length and this root's base, computed here and checked against
+ *     the ticket, so the Home, the naming service and the chain agree on the number.
+ *   - The fee moves from the payer to the fee treasury; the name is registered to `ticket.owner`; the owner is
+ *     recorded as having claimed under this root (one name per owner per root, never released); the price and the
+ *     time are stored so a reader never needs a log.
+ *
+ * What this is NOT (spec 431 D6): no expiry, no renewal, no resale, no refund. A paid name is an address card and
+ * grants nobody authority.
+ *
+ * Authority model: the registry sees `msg.sender == address(this)` AND `r.subregistry == this`; the child is owned
+ * by `ticket.owner`, never by this contract. Governance (gates, fee treasury, the price table) is the governor's —
+ * meant to be the root owner / the town's governor, and transferable.
+ */
+contract PricedSubregistry is ReentrancyGuard, EIP712 {
+    using SafeERC20 for IERC20;
+
+    AgentNameRegistry public immutable REGISTRY;
+    bytes32 public immutable PARENT_NODE;
+    address public immutable DEFAULT_RESOLVER;
+    IERC20 public immutable COIN;
+
+    uint256 public constant MIN_LABEL_LENGTH = 3;
+
+    /// @dev keccak256("ClaimTicket(bytes32 parentNode,string label,address owner,address payer,uint256 price,bytes32 domain,uint256 expiry,bytes32 nonce)")
+    bytes32 public constant CLAIM_TICKET_TYPEHASH =
+        keccak256("ClaimTicket(bytes32 parentNode,string label,address owner,address payer,uint256 price,bytes32 domain,uint256 expiry,bytes32 nonce)");
+
+    struct ClaimTicket {
+        bytes32 parentNode;
+        string label;
+        address owner;
+        address payer;
+        uint256 price;
+        /// @dev keccak256 of the domain the gate vouched for (`ibm.com`), or zero for an unprotected label.
+        bytes32 domain;
+        uint256 expiry;
+        bytes32 nonce;
+    }
+
+    address public governor;
+    address public feeTreasury;
+    /// @notice Estate naming gates whose tickets this root accepts.
+    mapping(address => bool) public gates;
+
+    /// @notice The price table: `base` in coin units for a label of 8+ characters; multipliers ×10 for lengths
+    ///         3, 4, 5, 6, 7 (an 8+ label is ×1); `cap` in coin units. Spec 431 §2.
+    uint256 public base;
+    uint16[5] public multipliersX10;
+    uint256 public cap;
+
+    /// @notice owner → the child node already claimed under this root (one per owner).
+    mapping(address => bytes32) public claimedBy;
+    /// @notice node → what was paid, and when. Readable without a log scan.
+    mapping(bytes32 => uint256) public paid;
+    mapping(bytes32 => uint64) public paidAt;
+    mapping(bytes32 => bool) public usedNonce;
+    uint256 public claimCount;
+
+    event NamePurchased(address indexed owner, address indexed payer, bytes32 indexed childNode, string label, uint256 price, bytes32 domain);
+    event GateSet(address indexed gate, bool allowed);
+    event FeeTreasurySet(address indexed feeTreasury);
+    event PriceTableSet(uint256 base, uint16[5] multipliersX10, uint256 cap);
+    event GovernorTransferred(address indexed oldGovernor, address indexed newGovernor);
+
+    error NotGovernor();
+    error ZeroAddress();
+    error WrongRoot();
+    error NotPayer();
+    error TicketExpired();
+    error NonceUsed();
+    error WrongPrice(uint256 expected);
+    error NotAGate(address signer);
+    error AlreadyClaimed(bytes32 existingNode);
+    error LabelTooShort();
+    error EmptyLabel();
+
+    modifier onlyGovernor() {
+        if (msg.sender != governor) revert NotGovernor();
+        _;
+    }
+
+    constructor(
+        AgentNameRegistry registry,
+        bytes32 parentNode,
+        address defaultResolver,
+        IERC20 coin,
+        address governor_,
+        address feeTreasury_,
+        uint256 base_,
+        uint16[5] memory multipliersX10_,
+        uint256 cap_
+    ) EIP712("PricedSubregistry", "1") {
+        if (governor_ == address(0) || feeTreasury_ == address(0) || address(coin) == address(0)) revert ZeroAddress();
+        REGISTRY = registry;
+        PARENT_NODE = parentNode;
+        DEFAULT_RESOLVER = defaultResolver;
+        COIN = coin;
+        governor = governor_;
+        feeTreasury = feeTreasury_;
+        base = base_;
+        multipliersX10 = multipliersX10_;
+        cap = cap_;
+    }
+
+    // ── the price ───────────────────────────────────────────────────────────────────────────────────────────
+
+    /// @notice What `label` costs under this root: `min(cap, base × multiplier(length))`. Pure in the label.
+    function priceOf(string calldata label) public view returns (uint256) {
+        uint256 len = bytes(label).length;
+        if (len < MIN_LABEL_LENGTH) revert LabelTooShort();
+        uint256 x10 = len >= 8 ? 10 : multipliersX10[len - 3];
+        uint256 p = (base * x10) / 10;
+        return p > cap ? cap : p;
+    }
+
+    // ── the claim ───────────────────────────────────────────────────────────────────────────────────────────
+
+    /// @notice The EIP-712 digest a gate signs for `t`.
+    function ticketDigest(ClaimTicket calldata t) public view returns (bytes32) {
+        return _hashTypedDataV4(keccak256(abi.encode(
+            CLAIM_TICKET_TYPEHASH, t.parentNode, keccak256(bytes(t.label)), t.owner, t.payer, t.price, t.domain, t.expiry, t.nonce
+        )));
+    }
+
+    /**
+     * @notice Buy `<label>.<root>` for `t.owner`, paid by `msg.sender` (= `t.payer`) with a ticket a gate signed.
+     *         Reverts when the ticket is for another root, expired, re-used, carries the wrong price, is signed by
+     *         nobody the governor named, when the owner already holds a name here, or when the registry refuses
+     *         (the label is taken).
+     */
+    function claim(ClaimTicket calldata t, bytes calldata gateSig) external nonReentrant returns (bytes32 childNode) {
+        if (bytes(t.label).length == 0) revert EmptyLabel();
+        if (t.parentNode != PARENT_NODE) revert WrongRoot();
+        if (t.payer != msg.sender) revert NotPayer();
+        if (t.owner == address(0)) revert ZeroAddress();
+        if (block.timestamp > t.expiry) revert TicketExpired();
+        if (usedNonce[t.nonce]) revert NonceUsed();
+        uint256 price = priceOf(t.label);
+        if (t.price != price) revert WrongPrice(price);
+        bytes32 prior = claimedBy[t.owner];
+        if (prior != bytes32(0)) revert AlreadyClaimed(prior);
+        address signer = ECDSA.recover(ticketDigest(t), gateSig);
+        if (!gates[signer]) revert NotAGate(signer);
+
+        usedNonce[t.nonce] = true;
+        if (price > 0) COIN.safeTransferFrom(msg.sender, feeTreasury, price);
+        // The registry is an immutable contract we control and does not call back here; the guard holds anyway.
+        // slither-disable-next-line reentrancy-no-eth
+        childNode = REGISTRY.register(PARENT_NODE, t.label, t.owner, DEFAULT_RESOLVER, 0);
+        claimedBy[t.owner] = childNode;
+        paid[childNode] = price;
+        paidAt[childNode] = uint64(block.timestamp);
+        unchecked { claimCount += 1; }
+        emit NamePurchased(t.owner, msg.sender, childNode, t.label, price, t.domain);
+    }
+
+    function hasClaimed(address owner) external view returns (bool) {
+        return claimedBy[owner] != bytes32(0);
+    }
+
+    // ── governance ──────────────────────────────────────────────────────────────────────────────────────────
+
+    function setGate(address gate, bool allowed) external onlyGovernor {
+        if (gate == address(0)) revert ZeroAddress();
+        gates[gate] = allowed;
+        emit GateSet(gate, allowed);
+    }
+
+    function setFeeTreasury(address feeTreasury_) external onlyGovernor {
+        if (feeTreasury_ == address(0)) revert ZeroAddress();
+        feeTreasury = feeTreasury_;
+        emit FeeTreasurySet(feeTreasury_);
+    }
+
+    function setPriceTable(uint256 base_, uint16[5] calldata multipliersX10_, uint256 cap_) external onlyGovernor {
+        base = base_;
+        multipliersX10 = multipliersX10_;
+        cap = cap_;
+        emit PriceTableSet(base_, multipliersX10_, cap_);
+    }
+
+    function transferGovernor(address newGovernor) external onlyGovernor {
+        if (newGovernor == address(0)) revert ZeroAddress();
+        emit GovernorTransferred(governor, newGovernor);
+        governor = newGovernor;
+    }
+}