@parity/product-sdk 0.22.0 → 0.24.0

package/dist/identity/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/identity/product-account.ts"],"names":[],"mappings":";;;;;AAoBA,IAAM,GAAA,GAAM,aAAa,UAAU,CAAA;AA8B5B,SAAS,kBAAA,CACZ,aAAA,EACA,OAAA,EACA,UAAA,GAAa,EAAA,EACG;AAChB,EAAA,MAAM,EAAE,SAAA,EAAW,eAAA,EAAgB,GAAI,WAAW,aAAa,CAAA;AAG/D,EAAA,MAAM,YAAA,GAAe,IAAI,WAAA,EAAY,CAAE,OAAO,OAAO,CAAA;AACrD,EAAA,MAAM,WAAW,IAAI,UAAA,CAAW,eAAA,CAAgB,MAAA,GAAS,aAAa,MAAM,CAAA;AAC5E,EAAA,QAAA,CAAS,GAAA,CAAI,iBAAiB,CAAC,CAAA;AAC/B,EAAA,QAAA,CAAS,GAAA,CAAI,YAAA,EAAc,eAAA,CAAgB,MAAM,CAAA;AAEjD,EAAA,MAAM,cAAA,GAAiB,WAAW,QAAQ,CAAA;AAC1C,EAAA,MAAM,OAAA,GAAU,UAAA,CAAW,cAAA,EAAgB,UAAU,CAAA;AACrD,EAAA,MAAM,WAAA,GAAc,WAAW,cAAc,CAAA;AAE7C,EAAA,GAAA,CAAI,MAAM,uBAAA,EAAyB;AAAA,IAC/B,aAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACH,CAAA;AAED,EAAA,OAAO;AAAA,IACH,OAAA;AAAA,IACA,WAAA;AAAA,IACA,aAAA;AAAA,IACA;AAAA,GACJ;AACJ;AAgBO,SAAS,kBAAA,CACZ,YAAA,EACA,aAAA,EACA,OAAA,EACO;AACP,EAAA,IAAI;AACA,IAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,aAAA,EAAe,OAAO,CAAA;AACzD,IAAA,MAAM,EAAE,SAAA,EAAW,QAAA,EAAS,GAAI,WAAW,YAAY,CAAA;AACvD,IAAA,MAAM,EAAE,SAAA,EAAW,UAAA,EAAW,GAAI,UAAA,CAAW,QAAQ,OAAO,CAAA;AAG5D,IAAA,IAAI,QAAA,CAAS,MAAA,KAAW,UAAA,CAAW,MAAA,EAAQ,OAAO,KAAA;AAClD,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,QAAA,CAAS,QAAQ,CAAA,EAAA,EAAK;AACtC,MAAA,IAAI,SAAS,CAAC,CAAA,KAAM,UAAA,CAAW,CAAC,GAAG,OAAO,KAAA;AAAA,IAC9C;AACA,IAAA,OAAO,IAAA;AAAA,EACX,CAAA,CAAA,MAAQ;AACJ,IAAA,OAAO,KAAA;AAAA,EACX;AACJ","file":"index.js","sourcesContent":["// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Context alias derivation (deprecated, removal in 0.23.0)\n *\n * Derives a deterministic, context-bound alias from a parent account using blake2b-256.\n *\n * The output is a hash, not a key, so no signing key exists for the addresses\n * returned here. See the notes on each function for what to use instead.\n *\n * NOTE: this is NOT the canonical sr25519 product-account derivation used by\n * mobile, desktop, and dotli hosts. For that, use\n * `@parity/product-sdk-keys::deriveProductAccountPublicKey`.\n */\n\nimport { createLogger } from \"@parity/product-sdk-logger\";\nimport { blake2b256 } from \"@parity/product-sdk-crypto\";\nimport { ss58Encode, ss58Decode, deriveH160 } from \"@parity/product-sdk-address\";\nimport type { ContextAliasInfo } from \"./types.js\";\n\nconst log = createLogger(\"identity\");\n\n/**\n * Derive a context-bound alias from a parent account.\n *\n * The alias is deterministically derived using:\n * aliasPublicKey = blake2b256(parentPublicKey || context)\n *\n * @deprecated Returns addresses that no key can spend. The alias public key is a\n *   blake2b-256 hash rather than a derived key, so no secret corresponds to the\n *   SS58 address or to the H160: both can receive value and neither can ever\n *   send it. Removal: `@parity/product-sdk` 0.23.0. Replace by intent:\n *\n *   - An account that holds or spends value:\n *     `SignerManager.getProductAccount(dotNsIdentifier, index)` from\n *     `@parity/product-sdk-signer`. Host-backed and actually signable.\n *   - The address offline, with no host: `deriveProductAccountPublicKey` from\n *     `@parity/product-sdk-keys`, the canonical sr25519 soft derivation.\n *   - An unlinkable per-context alias: select a registered ring-VRF key, then call\n *     `SignerManager.getProductAccountAlias(keyHandle, context, location)` or\n *     `createRingVRFProof(keyHandle, context, location, message)`.\n *   - A context-scoped identifier, never used as an account: `blake2b256` from\n *     `@parity/product-sdk/crypto`. Same bytes, without address packaging that\n *     invites the mistake.\n *\n * @param parentAddress - Parent account SS58 address\n * @param context - Context string for derivation (e.g. an app id or scope label)\n * @param ss58Prefix - SS58 prefix (default: 42)\n * @returns Context alias info\n */\nexport function deriveContextAlias(\n    parentAddress: string,\n    context: string,\n    ss58Prefix = 42,\n): ContextAliasInfo {\n    const { publicKey: parentPublicKey } = ss58Decode(parentAddress);\n\n    // Derive alias public key: blake2b-256(parentPublicKey || context)\n    const contextBytes = new TextEncoder().encode(context);\n    const combined = new Uint8Array(parentPublicKey.length + contextBytes.length);\n    combined.set(parentPublicKey, 0);\n    combined.set(contextBytes, parentPublicKey.length);\n\n    const aliasPublicKey = blake2b256(combined);\n    const address = ss58Encode(aliasPublicKey, ss58Prefix);\n    const h160Address = deriveH160(aliasPublicKey);\n\n    log.debug(\"Derived context alias\", {\n        parentAddress,\n        context,\n        address,\n    });\n\n    return {\n        address,\n        h160Address,\n        parentAddress,\n        context,\n    };\n}\n\n/**\n * Verify that a context alias was derived from a parent account.\n *\n * @deprecated Recomputes {@link deriveContextAlias} from two public values and\n *   compares the result, so it confirms a derivation relationship and nothing\n *   more. No secret enters the operation at any point, which means there is\n *   nothing here to authenticate: a passing result does not show that anyone\n *   controls either account. Removal: `@parity/product-sdk` 0.23.0.\n *\n * @param aliasAddress - Context alias SS58 address\n * @param parentAddress - Claimed parent address\n * @param context - Context string used for derivation\n * @returns True if derivation is valid\n */\nexport function verifyContextAlias(\n    aliasAddress: string,\n    parentAddress: string,\n    context: string,\n): boolean {\n    try {\n        const derived = deriveContextAlias(parentAddress, context);\n        const { publicKey: aliasKey } = ss58Decode(aliasAddress);\n        const { publicKey: derivedKey } = ss58Decode(derived.address);\n\n        // Compare public keys\n        if (aliasKey.length !== derivedKey.length) return false;\n        for (let i = 0; i < aliasKey.length; i++) {\n            if (aliasKey[i] !== derivedKey[i]) return false;\n        }\n        return true;\n    } catch {\n        return false;\n    }\n}\n"]}
+{"version":3,"sources":["../../src/identity/dotns-abis.ts","../../src/identity/dotns-errors.ts","../../src/identity/dotns-addresses.ts","../../src/identity/dotns-registry.ts"],"names":["ok","err"],"mappings":"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","file":"index.js","sourcesContent":["// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Minimal ABIs for the DotNS contracts: the read and write methods this module\n * calls, and nothing else. Sourced from `paritytech/dotns` (`contracts/registry`,\n * `contracts/resolvers`, `contracts/registrars`, `contracts/pop`).\n */\nimport type { AbiEntry } from \"@parity/product-sdk-contracts\";\n\n/**\n * `DotnsRegistry` — node → resolver / owner, plus the owner-gated pointer write.\n *\n * `setResolver` is needed because registration parks `records[node].resolver` on\n * the reverse resolver, so the pointer must be moved once before any address\n * record is readable.\n */\nexport const DOTNS_REGISTRY_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"resolver\",\n        inputs: [{ name: \"node\", type: \"bytes32\" }],\n        outputs: [{ name: \"\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"owner\",\n        inputs: [{ name: \"node\", type: \"bytes32\" }],\n        outputs: [{ name: \"\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"setResolver\",\n        inputs: [\n            { name: \"node\", type: \"bytes32\" },\n            { name: \"resolverAddr\", type: \"address\" },\n        ],\n        outputs: [],\n        stateMutability: \"nonpayable\",\n    },\n];\n\n/** `DotnsResolver` — node → resolved address. */\nexport const DOTNS_RESOLVER_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"addressOf\",\n        inputs: [{ name: \"node\", type: \"bytes32\" }],\n        outputs: [{ name: \"value\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/** `DotnsReverseResolver` — account → primary name. */\nexport const DOTNS_REVERSE_RESOLVER_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"nameOf\",\n        inputs: [{ name: \"addr\", type: \"address\" }],\n        outputs: [{ name: \"name\", type: \"string\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/** `DotnsResolver` write — set a node's resolved address (owner-gated). */\nexport const DOTNS_RESOLVER_WRITE_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"setAddress\",\n        inputs: [\n            { name: \"node\", type: \"bytes32\" },\n            { name: \"value\", type: \"address\" },\n        ],\n        outputs: [],\n        stateMutability: \"nonpayable\",\n    },\n];\n\n/**\n * `DotnsRegistrarController` — the commit-reveal registration flow. `register`\n * is payable; the value is the price from {@link DOTNS_POP_RULES_ABI}.\n * `Registration` = (label, owner, secret, reserved).\n */\nexport const DOTNS_REGISTRAR_CONTROLLER_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"available\",\n        inputs: [{ name: \"label\", type: \"string\" }],\n        outputs: [{ name: \"isAvailable\", type: \"bool\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"minCommitmentAge\",\n        inputs: [],\n        outputs: [{ name: \"\", type: \"uint256\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"maxCommitmentAge\",\n        inputs: [],\n        outputs: [{ name: \"\", type: \"uint256\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"makeCommitment\",\n        inputs: [\n            {\n                name: \"registration\",\n                type: \"tuple\",\n                components: [\n                    { name: \"label\", type: \"string\" },\n                    { name: \"owner\", type: \"address\" },\n                    { name: \"secret\", type: \"bytes32\" },\n                    { name: \"reserved\", type: \"bool\" },\n                ],\n            },\n        ],\n        outputs: [{ name: \"commitment\", type: \"bytes32\" }],\n        stateMutability: \"pure\",\n    },\n    {\n        type: \"function\",\n        name: \"commit\",\n        inputs: [{ name: \"commitment\", type: \"bytes32\" }],\n        outputs: [],\n        stateMutability: \"nonpayable\",\n    },\n    {\n        type: \"function\",\n        name: \"register\",\n        inputs: [\n            {\n                name: \"registration\",\n                type: \"tuple\",\n                components: [\n                    { name: \"label\", type: \"string\" },\n                    { name: \"owner\", type: \"address\" },\n                    { name: \"secret\", type: \"bytes32\" },\n                    { name: \"reserved\", type: \"bool\" },\n                ],\n            },\n        ],\n        outputs: [],\n        stateMutability: \"payable\",\n    },\n];\n\n/**\n * `PopRules` — registration pricing.\n *\n * `price` is the label-only cost and runs no eligibility rules, so it is not\n * what `register` charges. `register` uses the owner-aware variants and adds\n * `transferFloor` when the payer is not the owner:\n * `max(priceWithoutCheck(label, owner).price, transferFloor(label, payer, owner))`.\n *\n * `PopStatus` encodes as `uint8`: 0 NoStatus, 1 PopLite, 2 PopFull, 3 Reserved.\n */\nexport const DOTNS_POP_RULES_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"price\",\n        inputs: [{ name: \"name\", type: \"string\" }],\n        outputs: [{ name: \"cost\", type: \"uint256\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"priceWithoutCheck\",\n        inputs: [\n            { name: \"name\", type: \"string\" },\n            { name: \"userAddress\", type: \"address\" },\n        ],\n        outputs: [\n            {\n                name: \"metadata\",\n                type: \"tuple\",\n                components: [\n                    { name: \"price\", type: \"uint256\" },\n                    { name: \"status\", type: \"uint8\" },\n                    { name: \"userStatus\", type: \"uint8\" },\n                    { name: \"message\", type: \"string\" },\n                ],\n            },\n        ],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"classifyName\",\n        inputs: [{ name: \"name\", type: \"string\" }],\n        outputs: [\n            { name: \"requirement\", type: \"uint8\" },\n            { name: \"message\", type: \"string\" },\n        ],\n        stateMutability: \"pure\",\n    },\n    {\n        type: \"function\",\n        name: \"transferFloor\",\n        inputs: [\n            { name: \"name\", type: \"string\" },\n            { name: \"from\", type: \"address\" },\n            { name: \"to\", type: \"address\" },\n        ],\n        outputs: [{ name: \"floor\", type: \"uint256\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/**\n * `IDotnsProtocolRegistry`, the two TLD getters.\n *\n * The TLD is per network: `initialize(tldLabel)` fixes it once at deployment\n * and there is no setter, so these are immutable for the life of a deployment.\n * `tld()` returns the suffix with its leading dot (`\".paseo\"`); `tldNode()`\n * returns `namehash(0, labelhash(label))`, which is derivable from the suffix\n * and so is read only as a cross-check.\n *\n * Deployments predating `dotns` `b4096968` have neither getter — the TLD was a\n * compile-time constant there — and revert with an empty payload.\n */\nexport const DOTNS_PROTOCOL_REGISTRY_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"tld\",\n        inputs: [],\n        outputs: [{ name: \"suffix\", type: \"string\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"tldNode\",\n        inputs: [],\n        outputs: [{ name: \"node\", type: \"bytes32\" }],\n        stateMutability: \"view\",\n    },\n    {\n        type: \"function\",\n        name: \"get\",\n        inputs: [{ name: \"key\", type: \"bytes32\" }],\n        outputs: [{ name: \"addr\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/**\n * `RootGatewayDispatcher.TARGET`, the PoP controller it forwards to. `immutable`,\n * so a rotation means a new dispatcher and a new pallet value, which is why\n * discovery starts at the pallet rather than here.\n */\nexport const DOTNS_ROOT_GATEWAY_DISPATCHER_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"TARGET\",\n        inputs: [],\n        outputs: [{ name: \"\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/** `DotnsPopController.protocolRegistry`, the only hop that names the registry. */\nexport const DOTNS_POP_CONTROLLER_ABI: AbiEntry[] = [\n    {\n        type: \"function\",\n        name: \"protocolRegistry\",\n        inputs: [],\n        outputs: [{ name: \"\", type: \"address\" }],\n        stateMutability: \"view\",\n    },\n];\n\n/** `IPopRules.PopStatus`. Ordering is meaningful: a user meets a tier when `userStatus >= status`. */\nexport const POP_STATUS = { NoStatus: 0, PopLite: 1, PopFull: 2, Reserved: 3 } as const;\n\n/**\n * The deployed DotNS addresses. The same on every network.\n *\n * Not a per-network table, despite what the old name (`PASEO_ASSETHUB_DOTNS`)\n * implied: every DotNS network is deployed through the same CREATE3 factory, so\n * the addresses are identical everywhere and **only the TLD differs**, `.paseo`\n * on Paseo Asset Hub Next V2 and `.test` on Previewnet. Verified on both:\n * `protocolRegistry.get(...)` returns the same registry on each, and all six\n * addresses hold contracts on both. `paritytech/dotns` `DEPLOYMENTS.md` states the mechanism, and\n * `preview-net-v1` confirms it from the deploy side: the TLD is passed only as\n * registry init calldata, so it moves no address.\n *\n * So extending this module to another network means resolving its TLD, which\n * `resolveTld` already does — not adding a second address table.\n *\n * Five answer `DotnsProtocolRegistry.get(bytes32)` under the keys in\n * `DOTNS_REGISTRY_KEYS`, two of which differ from the field name used here.\n * `protocolRegistry` has no key and comes from the gateway walk. All six have a\n * `Revive.AccountInfoOf` entry.\n *\n * Pinned, not resolved at runtime: re-verify after a redeploy, or have the\n * client do it with `verifyDotNsAddresses`.\n */\nexport const DOTNS_ADDRESSES = {\n    registry: \"0xf34054fd76BbF85f216cf9908226D5f0A72E50CA\",\n    reverseResolver: \"0xee3883d7eB60Ee9BCD7F3bcD8f2f05302A9Cc035\",\n    resolver: \"0xbd1165E549DF96F083c0A16f61590927bC187009\",\n    registrarController: \"0xBdaA01bD1bA67d709F2b1fF286Da0d854977EA30\",\n    popRules: \"0x747B456bE03aec0b42bd85C51513730FBD45DA31\",\n    protocolRegistry: \"0xD19e3D0C97CF501125a04A97405e3e6592fa846E\",\n} as const;\n","// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\nimport type { SdkError } from \"@parity/product-sdk-errors\";\n\n/**\n * Error on the `Err` channel of a DotNS registry read/write. Implements the\n * cross-package {@link SdkError} marker so `isSdkError(e)` recognizes it.\n *\n * `reason` distinguishes the failure kind so callers can branch without string\n * matching.\n */\nexport type DotNsErrorReason =\n    | \"InvalidName\" // name failed isValidDotNsName\n    | \"InvalidTld\" // the deployment reported a TLD we cannot use, or the caller supplied an inconsistent one\n    | \"TldMismatch\" // a well-formed name, but rooted at another deployment's TLD\n    | \"MissingOrigin\" // a write was requested without the submitting account\n    | \"InvalidOrigin\" // the submitting account was supplied, but is not a decodable SS58 address\n    | \"NameUnavailable\" // already registered\n    | \"NameReserved\" // governance-held, or a base stem held by another user\n    | \"OwnerStatusInsufficient\" // the owner lacks the personhood tier the label requires\n    | \"AddressDiscovery\" // the gateway walk could not locate the deployment\n    | \"AddressMismatch\" // a discovered address disagrees with the one in use\n    | \"RegistryCall\" // the on-chain contract call failed\n    | \"Decode\"; // the contract returned something we couldn't decode\n\nexport class DotNsError extends Error implements SdkError {\n    readonly isSdkError = true as const;\n    readonly source = \"dotns\";\n    readonly reason: DotNsErrorReason;\n\n    constructor(reason: DotNsErrorReason, message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"DotNsError\";\n        this.reason = reason;\n    }\n}\n","// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Where the DotNS contract addresses come from.\n *\n * Every entry point in `./dotns-registry.js` asks {@link resolveDotNsAddresses}\n * rather than reaching for a constant, so \"which address do I call?\" has one\n * answer and the gateway walk can plug in behind it without touching them.\n */\nimport {\n    type AbiEntry,\n    type ContractRuntime,\n    QUERY_FALLBACK_ORIGIN,\n    createContract,\n} from \"@parity/product-sdk-contracts\";\nimport { type Result, err, ok } from \"@parity/result\";\nimport {\n    DOTNS_ADDRESSES,\n    DOTNS_POP_CONTROLLER_ABI,\n    DOTNS_PROTOCOL_REGISTRY_ABI,\n    DOTNS_ROOT_GATEWAY_DISPATCHER_ABI,\n} from \"./dotns-abis.js\";\nimport { DotNsError } from \"./dotns-errors.js\";\nimport type { SS58String } from \"polkadot-api\";\nimport type { DotNsClientOptions } from \"./dotns-registry.js\";\n\ntype HexString = `0x${string}`;\n\nexport interface DotNsAddresses {\n    registry: HexString;\n    reverseResolver: HexString;\n    resolver: HexString;\n    registrarController: HexString;\n    popRules: HexString;\n    protocolRegistry: HexString;\n}\n\n/**\n * The `DotnsProtocolRegistry.get(bytes32)` key each role answers under, from\n * `DotnsConstants`. Solidity's `bytes32(\"name\")` is the UTF-8 bytes\n * right-padded with zeros, which is what these literals are.\n *\n * Two are not the name you would guess, and guessing wrong is silent: `get`\n * answers with a live address for the contract you did not want, and it\n * surfaces much later as a revert. `registrarController` is the commit-reveal\n * controller, key `controller` — `registrar` is the ERC-721 holding name\n * ownership. `resolver` is the forward address resolver — `contentResolver`\n * holds contenthash and text records, which nothing here calls.\n *\n * `protocolRegistry` has no key at all, so it cannot be looked up in the\n * registry it is. The walk reaches it via `popController.protocolRegistry()`.\n */\nexport const DOTNS_REGISTRY_KEYS = {\n    registry: \"0x7265676973747279000000000000000000000000000000000000000000000000\",\n    registrarController: \"0x636f6e74726f6c6c657200000000000000000000000000000000000000000000\",\n    reverseResolver: \"0x726576657273655265736f6c7665720000000000000000000000000000000000\",\n    resolver: \"0x7265736f6c766572000000000000000000000000000000000000000000000000\",\n    popRules: \"0x706f7052756c6573000000000000000000000000000000000000000000000000\",\n} as const satisfies Record<Exclude<keyof DotNsAddresses, \"protocolRegistry\">, HexString>;\n\nexport const ZERO_ADDRESS = \"0x0000000000000000000000000000000000000000\";\n\nexport function isZero(addr: unknown): boolean {\n    return typeof addr === \"string\" && addr.toLowerCase() === ZERO_ADDRESS;\n}\n\n/** viem checksums every decoded `address`, so a read is EIP-55 whatever the chain sent. */\nexport function sameAddress(a: unknown, b: unknown): boolean {\n    return typeof a === \"string\" && typeof b === \"string\" && a.toLowerCase() === b.toLowerCase();\n}\n\n/** A per-runtime, per-key cache of chain reads that cannot change under us. */\nexport type RuntimeCache<T> = WeakMap<ContractRuntime, Map<string, Promise<Result<T, DotNsError>>>>;\n\n/**\n * Read `key` once per runtime and hand every later caller the same answer.\n *\n * Stores the in-flight promise rather than the resolved value, so concurrent\n * first calls share one read instead of racing. A failed read is dropped from\n * the cache: those are usually the RPC blinking rather than the deployment\n * moving, and keeping one would strand the client for the life of the runtime.\n */\nexport function cachedPerRuntime<T>(\n    cache: RuntimeCache<T>,\n    runtime: ContractRuntime,\n    key: string,\n    load: () => Promise<Result<T, DotNsError>>,\n): Promise<Result<T, DotNsError>> {\n    let byKey = cache.get(runtime);\n    if (!byKey) {\n        byKey = new Map();\n        cache.set(runtime, byKey);\n    }\n    const cached = byKey.get(key);\n    if (cached) return cached;\n\n    const pending = load();\n    byKey.set(key, pending);\n    pending.then((result) => {\n        if (!result.ok) byKey?.delete(key);\n    });\n    return pending;\n}\n\nfunction withOverrides(base: DotNsAddresses, opts: DotNsClientOptions): DotNsAddresses {\n    return {\n        registry: opts.registryAddress ?? base.registry,\n        reverseResolver: opts.reverseResolverAddress ?? base.reverseResolver,\n        resolver: opts.resolverAddress ?? base.resolver,\n        registrarController: opts.registrarControllerAddress ?? base.registrarController,\n        popRules: opts.popRulesAddress ?? base.popRules,\n        protocolRegistry: opts.protocolRegistryAddress ?? base.protocolRegistry,\n    };\n}\n\n/**\n * Async because the discovered source reads the chain. The pinned source does\n * no IO, so a caller that only validates a name still pays nothing for it.\n */\nconst walkCache: RuntimeCache<DotNsAddresses> = new WeakMap();\n\n/**\n * Constant, unlike the TLD cache which keys on the protocol registry address.\n * Nothing else selects the deployment: `gatewayApi` is required to describe the\n * same chain as `runtime`, and the walk derives every address from there.\n */\nconst WALK_KEY = \"discovered\";\n\nexport async function resolveDotNsAddresses(\n    opts: DotNsClientOptions,\n): Promise<Result<DotNsAddresses, DotNsError>> {\n    if (opts.addressSource !== \"discovered\") return ok(withOverrides(DOTNS_ADDRESSES, opts));\n\n    // Cache the walk, not the merged set: two callers differing only in their\n    // overrides must share one walk and still each get their own answer.\n    const walked = await cachedPerRuntime(walkCache, opts.runtime, WALK_KEY, () =>\n        discoverDotNsAddresses(opts),\n    );\n    return walked.ok ? ok(withOverrides(walked.value, opts)) : walked;\n}\n\n/**\n * Reads `DotnsGateway.DispatcherAddress`, the pallet storage the walk starts\n * from. Structural because `ContractRuntime` does not declare it.\n */\nexport type DotNsGatewayQueryApi = {\n    query: {\n        DotnsGateway: {\n            DispatcherAddress: {\n                getValue: () => Promise<{ asHex(): string } | string | undefined>;\n            };\n        };\n    };\n};\n\nconst discoveryFailed = (step: string, cause?: unknown) =>\n    err(new DotNsError(\"AddressDiscovery\", `DotNS address discovery failed: ${step}`, { cause }));\n\n/**\n * `createContract` is generic over a typed ABI def; these minimal literal ABIs\n * are called by name via `.query()`, so the handle is untyped by construction.\n */\nexport function contractOf(runtime: ContractRuntime, address: HexString, abi: AbiEntry[]) {\n    return createContract(runtime, address, abi as any) as any;\n}\n\n/**\n * Origin for a read. Passing the fallback explicitly rather than letting the\n * contracts layer substitute it keeps each query from logging a warning.\n */\nexport function readOrigin(opts: DotNsClientOptions): SS58String {\n    return opts.origin ?? QUERY_FALLBACK_ORIGIN;\n}\n\nasync function readAddress(\n    contract: {\n        [m: string]: { query: (o: object) => Promise<{ success: boolean; value: unknown }> };\n    },\n    method: string,\n    origin: string,\n): Promise<Result<HexString, DotNsError>> {\n    const res = await contract[method].query({ origin });\n    if (!res.success) return discoveryFailed(`${method}() failed`, res.value);\n    const value = res.value;\n    if (typeof value !== \"string\" || isZero(value)) {\n        return discoveryFailed(`${method}() returned no address`);\n    }\n    return ok(value as HexString);\n}\n\n/** PAPI hands back H160 as a wrapper or a hex string depending on the major. */\nfunction asH160(value: unknown): HexString | null {\n    if (typeof value === \"string\") return value as HexString;\n    if (value && typeof (value as { asHex?: unknown }).asHex === \"function\") {\n        return (value as { asHex(): string }).asHex() as HexString;\n    }\n    return null;\n}\n\nfunction gatewayOf(opts: DotNsClientOptions): DotNsGatewayQueryApi | null {\n    if (opts.gatewayApi) return opts.gatewayApi;\n    const api = opts.runtime?.api as unknown as Partial<DotNsGatewayQueryApi> | undefined;\n    const getValue = api?.query?.DotnsGateway?.DispatcherAddress?.getValue;\n    return typeof getValue === \"function\" ? (api as DotNsGatewayQueryApi) : null;\n}\n\n/**\n * Locate the live deployment from chain state, trusting nothing pinned here.\n *\n * Pallet -> `dispatcher.TARGET()` -> `popController.protocolRegistry()` ->\n * `get(key)` per role. The first three are sequential because each answer is\n * the next call's address; the role reads are not, so they go together.\n *\n * A failed or zero read is always an error: falling back to the pinned table\n * would recreate the situation this exists to detect, and hide it better.\n */\nexport async function discoverDotNsAddresses(\n    opts: DotNsClientOptions,\n): Promise<Result<DotNsAddresses, DotNsError>> {\n    try {\n        const gateway = gatewayOf(opts);\n        if (!gateway) {\n            return discoveryFailed(\n                \"no DotnsGateway.DispatcherAddress storage on this runtime; pass opts.gatewayApi\",\n            );\n        }\n        const dispatcher = asH160(await gateway.query.DotnsGateway.DispatcherAddress.getValue());\n        if (!dispatcher || isZero(dispatcher)) {\n            return discoveryFailed(\"DotnsGateway.DispatcherAddress is unset\");\n        }\n\n        const origin = readOrigin(opts);\n        const target = await readAddress(\n            contractOf(opts.runtime, dispatcher, DOTNS_ROOT_GATEWAY_DISPATCHER_ABI),\n            \"TARGET\",\n            origin,\n        );\n        if (!target.ok) return target;\n\n        const protocolRegistry = await readAddress(\n            contractOf(opts.runtime, target.value, DOTNS_POP_CONTROLLER_ABI),\n            \"protocolRegistry\",\n            origin,\n        );\n        if (!protocolRegistry.ok) return protocolRegistry;\n\n        const registry = contractOf(\n            opts.runtime,\n            protocolRegistry.value,\n            DOTNS_PROTOCOL_REGISTRY_ABI,\n        );\n        const roles = Object.entries(DOTNS_REGISTRY_KEYS) as [\n            keyof typeof DOTNS_REGISTRY_KEYS,\n            HexString,\n        ][];\n        // Not readAddress: that calls the method with no arguments, and these\n        // need the role name in the error rather than the method name, since\n        // every one of them is the same `get`.\n        const found = await Promise.all(\n            roles.map(async ([role, key]) => {\n                const res = await registry.get.query(key, { origin });\n                if (!res.success) return discoveryFailed(`get(${role}) failed`, res.value);\n                const value = res.value;\n                // A wrong key is not an error on chain: it returns address(0),\n                // so the role name is the only clue the caller gets.\n                if (typeof value !== \"string\" || isZero(value)) {\n                    return discoveryFailed(`${role} is unset on the protocol registry`);\n                }\n                return ok([role, value as HexString] as const);\n            }),\n        );\n        const failed = found.find((r) => !r.ok);\n        if (failed && !failed.ok) return failed;\n\n        const byRole = Object.fromEntries(found.flatMap((r) => (r.ok ? [r.value] : []))) as Omit<\n            DotNsAddresses,\n            \"protocolRegistry\"\n        >;\n        return ok({ ...byRole, protocolRegistry: protocolRegistry.value });\n    } catch (cause) {\n        return discoveryFailed(\"unexpected error\", cause);\n    }\n}\n\n/**\n * Walk the gateway and report every role whose live address differs from the\n * one this client would call. Meant for startup: it fails loudly once, rather\n * than making every later read pay for the check.\n */\nexport async function verifyDotNsAddresses(\n    opts: DotNsClientOptions,\n): Promise<Result<DotNsAddresses, DotNsError>> {\n    // Through the cache, so verifying at startup and then using the client is\n    // one walk rather than two.\n    const discovered = await cachedPerRuntime(walkCache, opts.runtime, WALK_KEY, () =>\n        discoverDotNsAddresses(opts),\n    );\n    if (!discovered.ok) return discovered;\n\n    // Compare what this client actually calls, which is the pinned table or the\n    // walk depending on the source, with the caller's overrides on top either\n    // way. A discovered client can still drift, through an override that\n    // disagrees with the chain; it is only the pinned base that cannot apply.\n    const inUse = withOverrides(\n        opts.addressSource === \"discovered\" ? discovered.value : DOTNS_ADDRESSES,\n        opts,\n    );\n    const drift = (Object.keys(inUse) as (keyof DotNsAddresses)[])\n        .filter((role) => !sameAddress(inUse[role], discovered.value[role]))\n        .map((role) => `${role}: using ${inUse[role]}, chain says ${discovered.value[role]}`);\n\n    return drift.length\n        ? err(\n              new DotNsError(\n                  \"AddressMismatch\",\n                  `DotNS addresses disagree with the deployment — ${drift.join(\"; \")}`,\n              ),\n          )\n        : ok(inUse);\n}\n","// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\n/**\n * DotNS registry reads and writes.\n *\n * DotNS is an ENS-style system on Asset Hub: a `DotnsRegistry` maps a node\n * (namehash) to a resolver + owner, a `DotnsResolver` maps a node to an\n * address, and a `DotnsReverseResolver` maps an account back to its name. All\n * are Revive contracts, reached via `@parity/product-sdk-contracts`'\n * `createContract(...).<method>.query(...)`. Contract source:\n * https://github.com/paritytech/dotns\n *\n * **Names are rooted at the network's TLD, which is per deployment.** It is\n * fixed when `DotnsProtocolRegistry.initialize` runs, has no setter, and is\n * published as `tld()`. `.paseo` on Paseo Asset Hub Next V2, `.test` on\n * Previewnet, and operators can choose others. Every entry point that hashes a\n * name therefore asks the chain first, through {@link resolveTld}, and callers\n * can supply `opts.tld` to skip the read. Hashing under the wrong root returns a\n * node the chain never wrote to, so the failure looks exactly like an\n * unregistered name — which is why nothing here assumes a root.\n *\n * **A node's resolver pointer is not necessarily a forward resolver.** The\n * deployment has several — forward, reverse, content, PoP — and only the forward\n * one answers `addressOf`. `resolveDotNs` therefore calls it only when the\n * pointer *is* the forward resolver, and reports every other pointer as\n * \"registered, no forward record\". The content resolver is the common case for a\n * product name.\n *\n * A rule this module holds to throughout: **a failed read must never become a\n * plausible value.** The one deliberate exception is documented on\n * {@link resolveTld}, where a missing getter identifies a deployment whose TLD\n * could only have been `.dot`.\n *\n * Reads (`resolveDotNs` / `reverseDotNs` / `isDotNsAvailable`) query chain.\n * Writes return prepared calls the caller submits with their own signer:\n * `setDotNsRecord` (the resolver pointer, when it needs moving, plus the\n * record) and `prepareDotNsRegistration` (the commit call plus a thunk for the\n * register call, which cannot be built until the commitment is on chain).\n *\n * Note: this deployment has no name-expiry concept (the registrar exposes no\n * expiry getter), so `DotNsRecord.expiresAt` is always omitted.\n */\nimport { err, ok, type Result } from \"@parity/result\";\nimport type { AbiEntry, BatchableCall, ContractRuntime } from \"@parity/product-sdk-contracts\";\nimport { bytesToHex, randomBytes } from \"@parity/product-sdk-crypto\";\nimport { ss58ToH160 } from \"@parity/product-sdk-address\";\nimport { createLogger } from \"@parity/product-sdk-logger\";\nimport type { SS58String } from \"polkadot-api\";\nimport {\n    DOTNS_POP_RULES_ABI,\n    DOTNS_PROTOCOL_REGISTRY_ABI,\n    DOTNS_REGISTRAR_CONTROLLER_ABI,\n    DOTNS_REGISTRY_ABI,\n    DOTNS_RESOLVER_ABI,\n    DOTNS_RESOLVER_WRITE_ABI,\n    DOTNS_REVERSE_RESOLVER_ABI,\n    DOTNS_ADDRESSES,\n    POP_STATUS,\n} from \"./dotns-abis.js\";\nimport { DotNsError } from \"./dotns-errors.js\";\nimport {\n    type DotNsGatewayQueryApi,\n    type RuntimeCache,\n    cachedPerRuntime,\n    contractOf,\n    isZero,\n    readOrigin,\n    resolveDotNsAddresses,\n    sameAddress,\n} from \"./dotns-addresses.js\";\nimport { isResolvableDotNsName, isValidDotNsName, normalizeDotNsName } from \"./dotns.js\";\nimport {\n    DOT_TLD,\n    dotNsTld,\n    type DotNsTld,\n    isConsistentDotNsTld,\n    namehash,\n    stripSuffix,\n} from \"./dotns-namehash.js\";\nimport type { DotNsRecord } from \"./types.js\";\n\nconst log = createLogger(\"identity:dotns\");\n\ntype HexString = `0x${string}`;\n\n/** Shared inputs for a DotNS registry call. */\nexport interface DotNsClientOptions {\n    /** A contract runtime for the chain hosting DotNS (Asset Hub). */\n    runtime: ContractRuntime;\n    /**\n     * SS58 account that will submit the prepared calls.\n     *\n     * Required by the write helpers, which dry-run against it: `setAddress` and\n     * `setResolver` are owner-gated, so a dry-run from anyone else reverts.\n     * Optional for reads, which fall back to the pallet-revive query account.\n     *\n     * Must be SS58, not the account's H160. pallet-revive derives `msg.sender`\n     * from it; convert with `h160ToSs58` from `@parity/product-sdk-address`.\n     */\n    origin?: SS58String;\n    /** `DotnsRegistry` address. Defaults to the deployed set, which is the same on every network. */\n    registryAddress?: HexString;\n    /** `DotnsReverseResolver` address. Defaults to the deployed set. */\n    reverseResolverAddress?: HexString;\n    /** `DotnsResolver` address (writes: setDotNsRecord). Defaults to Paseo AH. */\n    resolverAddress?: HexString;\n    /** `DotnsRegistrarController` address (registration). Defaults to Paseo AH. */\n    registrarControllerAddress?: HexString;\n    /** `PopRules` address (registration price). Defaults to Paseo AH. */\n    popRulesAddress?: HexString;\n    /**\n     * `DotnsProtocolRegistry` address, the contract holding this network's TLD.\n     * Defaults to Paseo AH — and the address is the same on every network, since\n     * the whole set is CREATE3-deterministic.\n     */\n    protocolRegistryAddress?: HexString;\n    /**\n     * Where the addresses come from. `\"pinned\"` (the default) uses the\n     * {@link DOTNS_ADDRESSES} table; `\"discovered\"` walks the gateway on the\n     * chain `runtime` points at, so nothing is trusted from this bundle.\n     *\n     * Pinned is the default because the table is currently correct and a walk\n     * costs four round trips on the first call. Discovery is the honest choice\n     * once a deployment has moved, and its trust root is\n     * `DotnsGateway.DispatcherAddress` — a governance-set value on the chain the\n     * caller already trusts for every name read. Per-field address overrides win\n     * over either source.\n     *\n     * Discovery also selects the address `setDotNsRecord` and\n     * `prepareDotNsRegistration` build calls against, so it decides where a\n     * signed transaction goes, not only where a read comes from. A pinned\n     * address constrains that destination even against a hostile RPC; a\n     * discovered one does not. Use {@link verifyDotNsAddresses} at startup if\n     * that matters.\n     */\n    addressSource?: \"pinned\" | \"discovered\";\n    /**\n     * Typed API for the chain hosting the `DotnsGateway` pallet, needed only by\n     * `\"discovered\"`.\n     *\n     * Optional because `runtime.api` is usually the same chain and is used when\n     * it carries the pallet. `ContractRuntime` does not declare that storage, so\n     * it is probed rather than assumed; on a chain without the pallet, discovery\n     * fails with `AddressDiscovery` instead of throwing.\n     */\n    gatewayApi?: DotNsGatewayQueryApi;\n    /**\n     * The deployment's TLD, when you already know it.\n     *\n     * Omit it and the client reads `protocolRegistry.tld()` once per runtime and\n     * caches it, which is the correct default: the TLD is per network and only\n     * the chain knows which one is in play. Supply it to skip the read for\n     * offline or test use, or to pin a deployment deliberately. Build it with\n     * `dotNsTld(\".paseo\")` rather than by hand — a suffix paired with the wrong\n     * node is rejected, because that pairing is the defect this option could\n     * otherwise reintroduce.\n     */\n    tld?: DotNsTld;\n}\n\n/** Arguments for {@link prepareDotNsRegistration}. */\nexport interface RegisterDotNsArgs {\n    /** The name to register, e.g. `\"alice.paseo\"` — or the bare label `\"alice\"`. */\n    name: string;\n    /**\n     * The account that will own the registered name: an H160, `0x` and 20\n     * bytes. Not SS58 — DotNS is a set of Revive contracts, and the registrar\n     * takes the owner as an ABI `address`. Convert with `ss58ToH160` from\n     * `@parity/product-sdk-address` if you hold a Substrate-shaped address.\n     *\n     * Typed `string` rather than `` `0x${string}` `` so callers need no cast,\n     * which means the compiler will not catch an SS58 address here: it reaches\n     * the contract and reverts on chain.\n     */\n    owner: string;\n    /** Reserved-name registration (default `false`). */\n    reserved?: boolean;\n}\n\n/** Arguments for {@link setDotNsRecord}. */\nexport interface SetRecordArgs {\n    /** The name whose resolver record is being set. */\n    name: string;\n    /**\n     * The address the name should resolve to: an H160, `0x` and 20 bytes. It is\n     * written straight into `resolver.setAddress` as an ABI `address`, so SS58\n     * is not accepted — convert with `ss58ToH160` from\n     * `@parity/product-sdk-address` first. Unenforced by the type, as with\n     * {@link RegisterDotNsArgs.owner}.\n     */\n    address: string;\n}\n\n// ── The deployment's TLD ─────────────────────────────────────────────\n//\n// Every node hash is rooted at the network's TLD, which is fixed when\n// `DotnsProtocolRegistry.initialize` runs and has no setter. Read it once per\n// (runtime, protocol registry) and cache it: it cannot change under us.\n\n/**\n * Cached TLD per runtime, then per protocol-registry address. Keyed on the\n * address as well because it is overridable, and one runtime pointed at two\n * registries has two TLDs.\n */\nconst tldCache: RuntimeCache<DotNsTld> = new WeakMap();\n\n/** An empty-payload revert: the contract ran and refused, telling us nothing. */\nfunction isEmptyRevert(value: unknown): boolean {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        (value as { type?: unknown }).type === \"ContractRevertedWithPayload\" &&\n        (value as { data?: unknown }).data === \"0x\"\n    );\n}\n\n/**\n * The TLD every name on this deployment is rooted at.\n *\n * Asks `protocolRegistry.tld()` and derives the node from the suffix, which is\n * exactly what `initialize` did — so `tldNode()` is only ever a cross-check, and\n * one read answers the question.\n *\n * Three outcomes, and the middle one is a deliberate exception to this module's\n * rule that a failed read must never become a plausible value:\n *\n *   - the getter answers with a usable suffix → that TLD;\n *   - the getter **reverts with an empty payload** → `DOT_TLD`, with a warning.\n *     That signature means the function does not exist, which dates the\n *     deployment before `dotns` `b4096968` (\"make the TLD network-configurable\n *     via the protocol registry\"). Before that commit the TLD was a\n *     compile-time constant and `.dot` was the only value it could hold, so\n *     this is the one case where the fallback is provably right rather than\n *     merely plausible. No live deployment is known to still take this\n *     branch: Previewnet was cited for it, but reports `.test`;\n *   - anything else → `err`. A dispatch failure, a revert carrying a reason, an\n *     undecodable answer, or a TLD we cannot use.\n *\n * That last case includes a getter that *succeeds* with an unusable value. The\n * registry is `UUPSUpgradeable` with no reinitializer, so a pre-`b4096968` proxy\n * upgraded to current contracts without a migration reports `_tld` as `\"\"` and\n * `_tldNode` as zero — both getters succeed and hand back the plain ENS root,\n * which would silently reroot every name. {@link isConsistentDotNsTld} is what\n * catches it.\n *\n * @internal Exposed for unit testing; consumers reach it through the entry points.\n */\nexport async function resolveTld(opts: DotNsClientOptions): Promise<Result<DotNsTld, DotNsError>> {\n    if (opts.tld) {\n        // A caller-supplied pair gets the same consistency check as a chain read:\n        // `.paseo` carrying `DOT_NODE` is the original bug via the override path.\n        return isConsistentDotNsTld(opts.tld)\n            ? ok(opts.tld)\n            : err(\n                  new DotNsError(\n                      \"InvalidTld\",\n                      `opts.tld is inconsistent: \"${opts.tld.suffix}\" does not hash to ${opts.tld.node}`,\n                  ),\n              );\n    }\n\n    const addresses = await resolveDotNsAddresses(opts);\n    if (!addresses.ok) return addresses;\n    const address = addresses.value.protocolRegistry;\n    return cachedPerRuntime(tldCache, opts.runtime, address, () => readTld(opts, address));\n}\n\nasync function readTld(\n    opts: DotNsClientOptions,\n    address: HexString,\n): Promise<Result<DotNsTld, DotNsError>> {\n    try {\n        const registry = contractOf(opts.runtime, address, DOTNS_PROTOCOL_REGISTRY_ABI);\n        const origin = readOrigin(opts);\n        const suffixRes = await registry.tld.query({ origin });\n\n        if (!suffixRes.success) {\n            if (isEmptyRevert(suffixRes.value)) {\n                log.warn(\n                    \"DotNS protocol registry has no tld() getter; treating this as a \" +\n                        \"pre-b4096968 deployment, whose TLD was the compile-time .dot\",\n                    { protocolRegistry: address },\n                );\n                return ok(DOT_TLD);\n            }\n            return err(\n                new DotNsError(\"RegistryCall\", \"protocolRegistry.tld call failed\", {\n                    cause: suffixRes.value,\n                }),\n            );\n        }\n\n        const suffix = suffixRes.value as string;\n        const tld = dotNsTld(suffix);\n        if (!isConsistentDotNsTld(tld)) {\n            return err(\n                new DotNsError(\n                    \"InvalidTld\",\n                    `protocolRegistry.tld returned an unusable TLD: ${JSON.stringify(suffix)}`,\n                ),\n            );\n        }\n\n        // Cross-check, not the source. A disagreement means the deployment's\n        // stored node was not derived from its stored label, which no\n        // `initialize` can produce — so trust neither value.\n        //\n        // Only a well-formed node counts as a disagreement. A revert (the getter\n        // is absent) or an unreadable answer means the cross-check did not run,\n        // which is not evidence against a suffix that already derived cleanly.\n        const nodeRes = await registry.tldNode.query({ origin });\n        if (nodeRes.success && isNode(nodeRes.value) && !sameNode(nodeRes.value, tld.node)) {\n            return err(\n                new DotNsError(\n                    \"InvalidTld\",\n                    `protocolRegistry disagrees with itself: tld() ${suffix} derives ` +\n                        `${tld.node} but tldNode() reports ${String(nodeRes.value)}`,\n                ),\n            );\n        }\n\n        log.debug(\"resolveTld\", { protocolRegistry: address, suffix: tld.suffix, node: tld.node });\n        return ok(tld);\n    } catch (cause) {\n        return err(new DotNsError(\"RegistryCall\", \"DotNS TLD read failed\", { cause }));\n    }\n}\n\n/**\n * Why a normalized name was refused.\n *\n * Two distinct answers, because they call for different things from the caller.\n * `TldMismatch` means the name is well formed but belongs to another\n * deployment — `alice.dot` handed to a `.paseo` network — which a product may\n * want to offer to correct, and which the SDK must never correct silently:\n * the two are separate registrations that may have different owners.\n * `InvalidName` means the labels themselves are malformed, and no rewrite helps.\n */\nfunction nameError(input: string, normalized: string, tld: DotNsTld): DotNsError {\n    if (!normalized.endsWith(tld.suffix)) {\n        return new DotNsError(\n            \"TldMismatch\",\n            `DotNS name \"${input}\" is not on this deployment, which uses \"${tld.suffix}\"`,\n        );\n    }\n    return new DotNsError(\"InvalidName\", `Invalid DotNS name: \"${input}\"`);\n}\n\n/** Whether a value is a readable 32-byte node, and so usable as a cross-check. */\nfunction isNode(value: unknown): value is HexString {\n    return typeof value === \"string\" && /^0x[0-9a-fA-F]{64}$/.test(value);\n}\n\n/** Case-insensitive 32-byte node compare, for the same reason as {@link sameAddress}. */\nfunction sameNode(a: string, b: string): boolean {\n    return a.toLowerCase() === b.toLowerCase();\n}\n\n/**\n * Resolve a DotNS name. `expiresAt` is omitted (no on-chain expiry here).\n *\n * Three outcomes, because the registry's resolver pointer is configuration, not\n * proof of existence:\n *\n *   - `ok(null)` — unregistered (`registry.owner` is zero).\n *   - `ok({ name, owner })` — registered, no forward record yet.\n *   - `ok({ name, owner, address })` — resolves.\n */\nexport async function resolveDotNs(\n    name: string,\n    opts: DotNsClientOptions,\n): Promise<Result<DotNsRecord | null, DotNsError>> {\n    // The TLD comes first because normalization and validation both need the\n    // suffix. One read per runtime, cached; an invalid name therefore costs a\n    // chain read on the first call and none after. Do not move validation back\n    // in front of this — it cannot know what a valid name looks like yet.\n    const tldRes = await resolveTld(opts);\n    if (!tldRes.ok) return tldRes;\n    const tld = tldRes.value;\n    const normalized = normalizeDotNsName(name, tld.suffix);\n    if (!isResolvableDotNsName(normalized, tld.suffix)) {\n        return err(nameError(name, normalized, tld));\n    }\n    const node = namehash(normalized, tld);\n    const addrs = await resolveDotNsAddresses(opts);\n    if (!addrs.ok) return addrs;\n    const registryAddr = addrs.value.registry;\n    const origin = readOrigin(opts);\n    log.debug(\"resolveDotNs\", { name: normalized, node, registry: registryAddr });\n\n    try {\n        const registry = contractOf(opts.runtime, registryAddr as HexString, DOTNS_REGISTRY_ABI);\n\n        const [ownerRes, resolverRes] = await Promise.all([\n            registry.owner.query(node, { origin }),\n            registry.resolver.query(node, { origin }),\n        ]);\n        if (!ownerRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"registry.owner call failed\", {\n                    cause: ownerRes.value,\n                }),\n            );\n        }\n        if (!resolverRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"registry.resolver call failed\", {\n                    cause: resolverRes.value,\n                }),\n            );\n        }\n\n        // Existence check: the getter falls back to the registrar's ERC-721\n        // holder, and returns zero for a node with no record.\n        const owner = ownerRes.value as HexString;\n        if (isZero(owner)) return ok(null);\n\n        // Only the forward resolver answers `addressOf`, so that is the one\n        // pointer worth calling — an allowlist, not a denylist of the resolvers\n        // we happen to have met. A node can legitimately point at the reverse\n        // resolver (where registration parks it), the content resolver (a\n        // product name serving content, and the ordinary case in practice), the\n        // PoP resolver, or one deployed after this was written. None of them has\n        // an address record to give, and all of them revert if asked — which\n        // would surface as an infrastructure failure for a name that is simply\n        // registered without a forward record.\n        //\n        // `setDotNsRecord` already compares against the forward resolver this\n        // way; before this, the read and write paths disagreed about what a\n        // pointer meant.\n        const resolverAddr = resolverRes.value as HexString;\n        const forwardAddr = addrs.value.resolver;\n        if (!sameAddress(resolverAddr, forwardAddr)) {\n            return ok({ name: normalized, owner });\n        }\n\n        const resolver = contractOf(opts.runtime, resolverAddr as HexString, DOTNS_RESOLVER_ABI);\n        const addrRes = await resolver.addressOf.query(node, { origin });\n        if (!addrRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"resolver.addressOf call failed\", {\n                    cause: addrRes.value,\n                }),\n            );\n        }\n        const address = addrRes.value as HexString;\n        // A forward resolver holding an empty record is still no forward record.\n        if (isZero(address)) return ok({ name: normalized, owner });\n\n        return ok({ address, name: normalized, owner });\n    } catch (cause) {\n        return err(\n            new DotNsError(\"RegistryCall\", `DotNS resolve failed for \"${normalized}\"`, { cause }),\n        );\n    }\n}\n\n/**\n * Reverse-resolve an account to its primary DotNS name.\n *\n * Single call: `reverseResolver.nameOf(account)`. `ok(null)` when no primary\n * name is set (empty string on-chain).\n */\nexport async function reverseDotNs(\n    address: string,\n    opts: DotNsClientOptions,\n): Promise<Result<string | null, DotNsError>> {\n    const addrs = await resolveDotNsAddresses(opts);\n    if (!addrs.ok) return addrs;\n    const reverseAddr = addrs.value.reverseResolver;\n    log.debug(\"reverseDotNs\", { address, reverseResolver: reverseAddr });\n    try {\n        const reverse = contractOf(\n            opts.runtime,\n            reverseAddr as HexString,\n            DOTNS_REVERSE_RESOLVER_ABI,\n        );\n        const res = await reverse.nameOf.query(address, { origin: readOrigin(opts) });\n        if (!res.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"reverseResolver.nameOf call failed\", {\n                    cause: res.value,\n                }),\n            );\n        }\n        const name = res.value as string;\n        return ok(name && name.length > 0 ? name : null);\n    } catch (cause) {\n        return err(\n            new DotNsError(\"RegistryCall\", `DotNS reverse failed for \"${address}\"`, { cause }),\n        );\n    }\n}\n\n/**\n * Whether a DotNS name is available to claim.\n *\n * Two reads, because \"not minted\" and \"claimable\" are different questions:\n *\n *   - `registrarController.available(label)`, the predicate `register` enforces\n *     through `_requireAvailableLabel`. Deliberately not inferred from\n *     resolution: a registered name has no forward record until its owner sets\n *     one, so that would report owned names as free.\n *   - `PopRules.classifyName(label)`, which is pure and owner-independent.\n *     Labels of 5 base characters or fewer are reserved for governance and can\n *     never be claimed, though the registrar still reports them as unminted.\n *\n * `ok(true)` means the name can be registered by someone. It does not mean the\n * caller can register it: labels of 6 to 8 characters additionally require a\n * personhood tier, which depends on the owner and is checked by\n * {@link prepareDotNsRegistration}.\n *\n * Validated first because both reads revert on labels we already reject.\n */\nexport async function isDotNsAvailable(\n    name: string,\n    opts: DotNsClientOptions,\n): Promise<Result<boolean, DotNsError>> {\n    const tldRes = await resolveTld(opts);\n    if (!tldRes.ok) return tldRes;\n    const tld = tldRes.value;\n    const normalized = normalizeDotNsName(name, tld.suffix);\n    if (!isValidDotNsName(normalized, tld.suffix)) {\n        return err(nameError(name, normalized, tld));\n    }\n    // The registrar takes the bare label, without the TLD suffix.\n    const label = stripSuffix(normalized, tld.suffix);\n    const addrs = await resolveDotNsAddresses(opts);\n    if (!addrs.ok) return addrs;\n    const controllerAddr = addrs.value.registrarController;\n    log.debug(\"isDotNsAvailable\", { name: normalized, label, controller: controllerAddr });\n\n    try {\n        const controller = contractOf(\n            opts.runtime,\n            controllerAddr as HexString,\n            DOTNS_REGISTRAR_CONTROLLER_ABI,\n        );\n        const popRules = contractOf(opts.runtime, addrs.value.popRules, DOTNS_POP_RULES_ABI);\n        const origin = readOrigin(opts);\n        const [res, classified] = await Promise.all([\n            controller.available.query(label, { origin }),\n            popRules.classifyName.query(label, { origin }),\n        ]);\n        if (!res.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"registrarController.available call failed\", {\n                    cause: res.value,\n                }),\n            );\n        }\n        if (res.value !== true) return ok(false);\n\n        // classifyName reverts on a label shape the registrar rejects, so a\n        // failure here is surfaced rather than folded into `false`.\n        if (!classified.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"PopRules.classifyName call failed\", {\n                    cause: classified.value,\n                }),\n            );\n        }\n        const { requirement } = classified.value as { requirement: number; message: string };\n        return ok(requirement !== POP_STATUS.Reserved);\n    } catch (cause) {\n        return err(\n            new DotNsError(\"RegistryCall\", `DotNS availability check failed for \"${normalized}\"`, {\n                cause,\n            }),\n        );\n    }\n}\n\n// ── Writes ───────────────────────────────────────────────────────────\n//\n// Writes return prepared calls (`BatchableCall`) the caller submits with their\n// own signer via `@parity/product-sdk-tx` — the surface stays signer-free, like\n// the reads. Registration is a two-transaction commit-reveal, so it can't be a\n// single call; `prepareDotNsRegistration` returns both plus the timing window.\n\n/**\n * Prepare the calls binding a name to an address. Submit them in order with the\n * owner's signer via `batchSubmitAndWatch`; both are owner-gated.\n *\n * Returns two calls when the node still points at the reverse resolver (the\n * post-registration default): `registry.setResolver` first, or the record\n * written by `setAddress` is real but unreadable. One call once it is pointed.\n */\nexport async function setDotNsRecord(\n    args: SetRecordArgs,\n    opts: DotNsClientOptions,\n): Promise<Result<BatchableCall[], DotNsError>> {\n    const tldRes = await resolveTld(opts);\n    if (!tldRes.ok) return tldRes;\n    const tld = tldRes.value;\n    const normalized = normalizeDotNsName(args.name, tld.suffix);\n    if (!isResolvableDotNsName(normalized, tld.suffix)) {\n        return err(nameError(args.name, normalized, tld));\n    }\n    // Both calls are owner-gated, so a dry-run from the fallback account would\n    // revert and the error would look like a contract problem.\n    const origin = opts.origin;\n    if (!origin) {\n        return err(new DotNsError(\"MissingOrigin\", \"setDotNsRecord needs opts.origin (SS58)\"));\n    }\n    const node = namehash(normalized, tld);\n    const addrs = await resolveDotNsAddresses(opts);\n    if (!addrs.ok) return addrs;\n    const registryAddr = addrs.value.registry;\n    const resolverAddr = addrs.value.resolver;\n    try {\n        const registry = contractOf(opts.runtime, registryAddr as HexString, DOTNS_REGISTRY_ABI);\n        const currentRes = await registry.resolver.query(node, { origin });\n        if (!currentRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"registry.resolver call failed\", {\n                    cause: currentRes.value,\n                }),\n            );\n        }\n\n        const calls: BatchableCall[] = [];\n        if (!sameAddress(currentRes.value, resolverAddr)) {\n            const pointer = await registry.setResolver.prepare(node, resolverAddr, { origin });\n            if (!pointer.ok) {\n                return err(\n                    new DotNsError(\"RegistryCall\", \"registry.setResolver prepare failed\", {\n                        cause: pointer.error,\n                    }),\n                );\n            }\n            calls.push(pointer.value as BatchableCall);\n        }\n\n        const resolver = contractOf(\n            opts.runtime,\n            resolverAddr as HexString,\n            DOTNS_RESOLVER_WRITE_ABI,\n        );\n        const prepared = await resolver.setAddress.prepare(node, args.address, { origin });\n        if (!prepared.ok) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"resolver.setAddress prepare failed\", {\n                    cause: prepared.error,\n                }),\n            );\n        }\n        calls.push(prepared.value as BatchableCall);\n\n        return ok(calls);\n    } catch (cause) {\n        return err(new DotNsError(\"RegistryCall\", \"DotNS setRecord failed\", { cause }));\n    }\n}\n\n/** The prepared pieces of a DotNS registration. */\nexport interface DotNsRegistration {\n    /** The random secret bound into both commit and register. */\n    secret: HexString;\n    /** The commitment hash (also encoded inside `commitCall`). */\n    commitment: HexString;\n    /** Submit first, with the owner's signer. */\n    commitCall: BatchableCall;\n    /** Seconds to wait after `commit` before `register` is accepted. */\n    minCommitmentAge: bigint;\n    /** Seconds after which the commitment expires and `register` is rejected. */\n    maxCommitmentAge: bigint;\n    /** Quote at prepare time, for display. The submitted value is re-read below. */\n    price: bigint;\n    /**\n     * Build the register call, once `minCommitmentAge` has elapsed.\n     *\n     * Deferred rather than returned up front: `register` consumes the\n     * commitment, so dry-running it before `commitCall` lands reverts with\n     * `CommitmentNotFound` and no call could be built at all. Deferring also\n     * prices and sizes it against the state it will actually execute in.\n     */\n    prepareRegisterCall: () => Promise<Result<BatchableCall, DotNsError>>;\n}\n\n/** What `register` will charge, and whether it will accept the owner at all. */\nasync function quoteRegistration(\n    popRules: ReturnType<typeof contractOf>,\n    label: string,\n    owner: string,\n    payer: string,\n    origin: SS58String,\n): Promise<Result<bigint, DotNsError>> {\n    // `price(label)` is not what register charges: it skips every eligibility\n    // rule and ignores the owner. The owner-aware variant reports the same\n    // classification register applies, without reverting on it.\n    const quote = await popRules.priceWithoutCheck.query(label, owner, { origin });\n    if (!quote.success) {\n        return err(\n            new DotNsError(\"RegistryCall\", \"PopRules.priceWithoutCheck failed\", {\n                cause: quote.value,\n            }),\n        );\n    }\n    const { price, status, userStatus, message } = quote.value as {\n        price: bigint;\n        status: number;\n        userStatus: number;\n        message: string;\n    };\n    if (status === POP_STATUS.Reserved) {\n        return err(new DotNsError(\"NameReserved\", `\"${label}\" is reserved: ${message}`));\n    }\n    if (userStatus < status) {\n        return err(\n            new DotNsError(\n                \"OwnerStatusInsufficient\",\n                `\"${label}\" requires personhood tier ${status}, owner has ${userStatus}: ${message}`,\n            ),\n        );\n    }\n\n    // Cross-payer registrations add a friction floor; register charges the\n    // larger of the two.\n    if (sameAddress(payer, owner)) return ok(BigInt(price));\n    const floor = await popRules.transferFloor.query(label, payer, owner, { origin });\n    if (!floor.success) {\n        return err(\n            new DotNsError(\"RegistryCall\", \"PopRules.transferFloor failed\", {\n                cause: floor.value,\n            }),\n        );\n    }\n    const friction = BigInt(floor.value as string | number | bigint);\n    const base = BigInt(price);\n    return ok(base > friction ? base : friction);\n}\n\n/**\n * Prepare a DotNS registration: the commit call, the shared secret, the timing\n * window, and a thunk that builds the register call afterwards.\n *\n *   1. submit `commitCall`\n *   2. wait `minCommitmentAge`, and register before `maxCommitmentAge`\n *   3. `await prepareRegisterCall()`, then submit what it returns\n *\n * Eligibility is checked here, before the caller pays for the commit: a\n * governance-reserved label, or an owner below the tier the label requires,\n * fails now rather than on the second transaction.\n */\nexport async function prepareDotNsRegistration(\n    args: RegisterDotNsArgs,\n    opts: DotNsClientOptions,\n): Promise<Result<DotNsRegistration, DotNsError>> {\n    const tldRes = await resolveTld(opts);\n    if (!tldRes.ok) return tldRes;\n    const tld = tldRes.value;\n    const normalized = normalizeDotNsName(args.name, tld.suffix);\n    if (!isValidDotNsName(normalized, tld.suffix)) {\n        return err(nameError(args.name, normalized, tld));\n    }\n    const origin = opts.origin;\n    if (!origin) {\n        return err(\n            new DotNsError(\"MissingOrigin\", \"prepareDotNsRegistration needs opts.origin (SS58)\"),\n        );\n    }\n    // The registrar takes the bare label, without the TLD suffix.\n    const label = stripSuffix(normalized, tld.suffix);\n    const addrs = await resolveDotNsAddresses(opts);\n    if (!addrs.ok) return addrs;\n    const controllerAddr = addrs.value.registrarController;\n    const popRulesAddr = addrs.value.popRules;\n    const secret = `0x${bytesToHex(randomBytes(32))}` as HexString;\n    const registration = { label, owner: args.owner, secret, reserved: args.reserved ?? false };\n    // register compares msg.sender against the owner; msg.sender is derived\n    // from the SS58 origin, so derive it the same way to predict the branch.\n    // ss58ToH160 throws on an undecodable address, and this sits outside the\n    // try below, so guard it here rather than letting it escape the Result.\n    let payer: HexString;\n    try {\n        payer = ss58ToH160(origin);\n    } catch (cause) {\n        return err(\n            new DotNsError(\"InvalidOrigin\", `opts.origin is not a valid SS58 address: ${origin}`, {\n                cause,\n            }),\n        );\n    }\n\n    try {\n        const controller = contractOf(\n            opts.runtime,\n            controllerAddr as HexString,\n            DOTNS_REGISTRAR_CONTROLLER_ABI,\n        );\n        const popRules = contractOf(opts.runtime, popRulesAddr as HexString, DOTNS_POP_RULES_ABI);\n\n        const [commitmentRes, availableRes, quote, minRes, maxRes] = await Promise.all([\n            controller.makeCommitment.query(registration, { origin }),\n            controller.available.query(label, { origin }),\n            quoteRegistration(popRules, label, args.owner, payer, origin),\n            controller.minCommitmentAge.query({ origin }),\n            controller.maxCommitmentAge.query({ origin }),\n        ]);\n        // `register` runs _requireAvailableLabel before anything else, so a\n        // taken name costs the caller a commit fee and then reverts.\n        if (!availableRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"registrarController.available call failed\", {\n                    cause: availableRes.value,\n                }),\n            );\n        }\n        if (availableRes.value !== true) {\n            return err(new DotNsError(\"NameUnavailable\", `\"${label}\" is already registered`));\n        }\n        if (!commitmentRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"makeCommitment failed\", {\n                    cause: commitmentRes.value,\n                }),\n            );\n        }\n        if (!quote.ok) return quote;\n        if (!minRes.success || !maxRes.success) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"commitment window read failed\", {\n                    cause: minRes.success ? maxRes.value : minRes.value,\n                }),\n            );\n        }\n        const commitment = commitmentRes.value as HexString;\n\n        const commitPrep = await controller.commit.prepare(commitment, { origin });\n        if (!commitPrep.ok) {\n            return err(\n                new DotNsError(\"RegistryCall\", \"controller.commit prepare failed\", {\n                    cause: commitPrep.error,\n                }),\n            );\n        }\n\n        return ok({\n            secret,\n            commitment,\n            commitCall: commitPrep.value as BatchableCall,\n            minCommitmentAge: BigInt(minRes.value as string | number),\n            maxCommitmentAge: BigInt(maxRes.value as string | number),\n            price: quote.value,\n            prepareRegisterCall: async () => {\n                // Re-quoted, not reused: the price and the owner's tier can both\n                // move during the mandatory wait.\n                const current = await quoteRegistration(popRules, label, args.owner, payer, origin);\n                if (!current.ok) return current;\n                const prep = await controller.register.prepare(registration, {\n                    value: current.value,\n                    origin,\n                });\n                if (!prep.ok) {\n                    return err(\n                        new DotNsError(\"RegistryCall\", \"controller.register prepare failed\", {\n                            cause: prep.error,\n                        }),\n                    );\n                }\n                return ok(prep.value as BatchableCall);\n            },\n        });\n    } catch (cause) {\n        return err(new DotNsError(\"RegistryCall\", \"DotNS registration prepare failed\", { cause }));\n    }\n}\n"]}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { LogEntry, LogHandler, LogLevel, Logger, LoggerConfig, configure, createLogger } from '@parity/product-sdk-logger';
-import { c as AppConfig, b as App } from './types-DTgyMIi0.js';
-export { A as Account, C as ChainApi, a as CloudStorageApi, D as DotNsIdentitySignature, L as LocalStorageApi, S as SignMessageWithDotNsIdentityArgs, W as WalletApi } from './types-DTgyMIi0.js';
+import { c as AppConfig, b as App } from './types-CRYPRNYk.js';
+export { A as Account, C as ChainApi, a as CloudStorageApi, D as DotNsIdentitySignature, L as LocalStorageApi, S as SignMessageWithDotNsIdentityArgs, W as WalletApi } from './types-CRYPRNYk.js';
 export { Result, err, isErrorOf, ok } from '@parity/result';
 export { SdkError, isSdkError } from '@parity/product-sdk-errors';
 export { isInsideContainer, isInsideContainerSync } from '@parity/product-sdk-host';
@@ -9,7 +9,7 @@ export { SignerManager } from '@parity/product-sdk-signer';
 export { createLocalKvStore } from '@parity/product-sdk-local-storage';
 export { CloudStorageClient, calculateCid } from '@parity/product-sdk-cloud-storage';
 export { ChainDefinition, PolkadotClient, TypedApi } from 'polkadot-api';
-import './dotns-DIaptENj.js';
+import './dotns-CtmOwVQW.js';
 
 /**
  * createApp - Main entry point for the Product SDK

package/dist/index.js

@@ -1,6 +1,6 @@
 export { configure, createLogger } from './chunk-JVJ552RU.js';
-export { createApp } from './chunk-6BI66XUJ.js';
-import './chunk-BIKT6X54.js';
+export { createApp } from './chunk-JIO3OZSC.js';
+import './chunk-7GM3HUZF.js';
 export { err, isErrorOf, ok } from '@parity/result';
 export { isSdkError } from '@parity/product-sdk-errors';
 export { isInsideContainer, isInsideContainerSync } from '@parity/product-sdk-host';

package/dist/react/index.d.ts

@@ -2,12 +2,12 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { LogLevel } from '@parity/product-sdk-logger';
-import { b as App, S as SignMessageWithDotNsIdentityArgs, D as DotNsIdentitySignature, A as Account } from '../types-DTgyMIi0.js';
+import { b as App, S as SignMessageWithDotNsIdentityArgs, D as DotNsIdentitySignature, A as Account } from '../types-CRYPRNYk.js';
 import { ChainDefinition, TypedApi } from 'polkadot-api';
 import '@parity/product-sdk-cloud-storage';
 import '@parity/result';
 import '@parity/product-sdk-chain-client';
-import '../dotns-DIaptENj.js';
+import '../dotns-CtmOwVQW.js';
 
 /** Props for ProductSDKProvider */
 interface ProductSDKProviderProps {

package/dist/react/index.js

@@ -1,5 +1,5 @@
-import { createApp } from '../chunk-6BI66XUJ.js';
-import '../chunk-BIKT6X54.js';
+import { createApp } from '../chunk-JIO3OZSC.js';
+import '../chunk-7GM3HUZF.js';
 import { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { A as Account, L as LocalStorageApi, C as ChainApi, a as CloudStorageApi, b as App } from '../types-DTgyMIi0.js';
+import { A as Account, L as LocalStorageApi, C as ChainApi, a as CloudStorageApi, b as App } from '../types-CRYPRNYk.js';
 export * from '@parity/product-sdk-local-storage/testing';
 export * from '@parity/product-sdk-signer/testing';
 export * from '@parity/product-sdk-contracts/testing';
@@ -7,7 +7,7 @@ import '@parity/product-sdk-logger';
 import '@parity/product-sdk-cloud-storage';
 import '@parity/result';
 import '@parity/product-sdk-chain-client';
-import '../dotns-DIaptENj.js';
+import '../dotns-CtmOwVQW.js';
 import 'polkadot-api';
 
 /** Configurable behavior for the fake {@link WalletApi}. */

package/dist/{types-DTgyMIi0.d.ts → types-CRYPRNYk.d.ts}

@@ -2,7 +2,7 @@ import { LogLevel } from '@parity/product-sdk-logger';
 import { ProductCloudStorageError, CloudStorageEnvironment } from '@parity/product-sdk-cloud-storage';
 import { Result } from '@parity/result';
 import { ChainClient } from '@parity/product-sdk-chain-client';
-import { P as PeopleUsernameChain } from './dotns-DIaptENj.js';
+import { P as PeopleUsernameChain } from './dotns-CtmOwVQW.js';
 import { ChainDefinition, TypedApi, PolkadotClient } from 'polkadot-api';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity/product-sdk",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Unified SDK for building products in the Polkadot ecosystem - umbrella package",
   "type": "module",
   "sideEffects": false,
@@ -71,20 +71,20 @@
   ],
   "dependencies": {
     "polkadot-api": "^2.1.6",
-    "@parity/product-sdk-address": "0.1.1",
-    "@parity/product-sdk-cloud-storage": "0.10.1",
-    "@parity/product-sdk-contracts": "0.10.2",
-    "@parity/product-sdk-chain-client": "0.11.0",
+    "@parity/product-sdk-contracts": "0.10.4",
+    "@parity/product-sdk-address": "0.2.0",
+    "@parity/product-sdk-chain-client": "0.12.0",
+    "@parity/product-sdk-cloud-storage": "0.11.0",
     "@parity/product-sdk-crypto": "0.1.1",
-    "@parity/product-sdk-host": "0.16.0",
-    "@parity/product-sdk-individuality": "0.1.0",
-    "@parity/product-sdk-keys": "0.3.19",
-    "@parity/product-sdk-logger": "0.1.1",
+    "@parity/product-sdk-individuality": "0.2.0",
+    "@parity/product-sdk-host": "0.17.0",
+    "@parity/product-sdk-keys": "0.3.21",
     "@parity/product-sdk-errors": "0.2.0",
+    "@parity/product-sdk-logger": "0.1.1",
     "@parity/result": "0.2.0",
-    "@parity/product-sdk-signer": "0.13.0",
-    "@parity/product-sdk-tx": "0.4.2",
-    "@parity/product-sdk-local-storage": "0.3.5"
+    "@parity/product-sdk-signer": "0.14.1",
+    "@parity/product-sdk-tx": "0.4.4",
+    "@parity/product-sdk-local-storage": "0.3.6"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/core/createApp.ts

@@ -32,9 +32,10 @@ import {
     isConnected,
     destroyAll,
 } from "@parity/product-sdk-chain-client";
+import { accountIdBytes } from "@parity/product-sdk-address";
 import { getAccountsProvider } from "@parity/product-sdk-host";
 import {
-    accountIdHexToBytes,
+    accountIdBytesToHex,
     type PeopleUsernameQueryApi,
     resolvePeopleUsernameOwner,
 } from "../identity/dotns.js";
@@ -321,16 +322,17 @@ function createWalletApi(signerManager: SignerManager): WalletApi {
             const peopleApi = peopleClient.getTypedApi(
                 args.peopleChain,
             ) as unknown as PeopleUsernameQueryApi;
-            const accountId = await resolvePeopleUsernameOwner(username, peopleApi);
-            if (!accountId) {
+            const owner = await resolvePeopleUsernameOwner(username, peopleApi);
+            if (!owner) {
                 throw new Error(`No account owns DotNS username "${username}"`);
             }
 
-            const owner = accountIdHexToBytes(accountId);
-            const signer = accountsProvider.getLegacyAccountSigner({
-                publicKey: owner,
-                name: username,
-            });
+            const publicKey = accountIdBytes(owner);
+            // This field is hex, not the SS58 the resolver now returns. Converted
+            // here and not in the try, so an address failure is not reported as a
+            // signing failure.
+            const accountId = accountIdBytesToHex(publicKey);
+            const signer = accountsProvider.getLegacyAccountSigner({ publicKey, name: username });
 
             try {
                 return {

package/src/identity/dotns-abis.test.ts

@@ -0,0 +1,43 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Guards on the transcribed deployment table. These check the shape of the
+// table, not that it names the live deployment: only a diff against
+// `paritytech/dotns` `deployments/paseo-assethub/420420417.json` can do that,
+// and it is a network fetch. See the comment on DOTNS_ADDRESSES for the
+// commit the values were copied from, and re-check it when bumping.
+import { isValidH160 } from "@parity/product-sdk-address";
+import { describe, expect, test } from "vitest";
+import { DOTNS_ADDRESSES } from "./dotns-abis.js";
+
+describe("DOTNS_ADDRESSES", () => {
+    test("every entry is a well-formed H160", () => {
+        for (const [name, address] of Object.entries(DOTNS_ADDRESSES)) {
+            expect(isValidH160(address), `${name} = ${address}`).toBe(true);
+        }
+    });
+
+    test("no two entries share an address", () => {
+        // Six addresses transcribed by hand: a duplicated paste is the
+        // transcription error most likely to go unnoticed, because the wrong
+        // contract still answers and only the decode looks odd.
+        const entries = Object.entries(DOTNS_ADDRESSES);
+        const seen = new Map<string, string>();
+        for (const [name, address] of entries) {
+            const key = address.toLowerCase();
+            expect(seen.get(key), `${name} duplicates ${seen.get(key)}`).toBeUndefined();
+            seen.set(key, name);
+        }
+        expect(seen.size).toBe(entries.length);
+    });
+
+    test("the resolver and the reverse resolver are different contracts", () => {
+        // Load-bearing beyond general distinctness: resolveDotNs decides whether
+        // a node has a forward record by comparing the registry's resolver
+        // pointer against the reverse resolver, so collapsing these two would
+        // make every registered name look resolvable.
+        expect(DOTNS_ADDRESSES.resolver.toLowerCase()).not.toBe(
+            DOTNS_ADDRESSES.reverseResolver.toLowerCase(),
+        );
+    });
+});