@sorandomains/owner 0.10.1 → 0.12.0

package/dist/native-upgrades.js

@@ -0,0 +1,93 @@
+import { NativeClaimError, address, bool, bytes32, exactObject, hex, namespaceNode, sc, u32 } from "./native-codec.js";
+import { expectedNativeCode } from "./native-code-policy.js";
+/**
+ * Reviewed implementation lineage of the governed testnet Registry. Governance
+ * approval means "this hash may be installed on any namespace", not "this is a
+ * safe transition": superseded releases stay approved, so the chain accepts a
+ * downgrade. `latest` is the release owners are offered; `superseded` are the
+ * older releases it replaces. A test keeps this equal to the web catalog
+ * (web/lib/contractUpdates.ts) and the release record; adding a release means
+ * moving the old `latest` into `superseded` here and there.
+ */
+export const CONTRACT_RELEASES = {
+    registrar: {
+        latest: "4d6d18625f4d890028acb794b24871c5c93f96dc15d94cf3d52cbf9713b07fb1",
+        superseded: [
+            "42dc5f8b40932617d3f2667e1d26dad3e5e9a62c63de1fde7c016cb67a86c420",
+            "5c8ae72ea7370ccf19af52b9bbc0007362be94464651ccdf68a2bb1f478b6f2c",
+            "61ded153e6311075c1087c5639a5410222e23f7cade239ed2c946150af94b1c5",
+            "26e03cd1d7fbfa46fe442406fb1b88022ec8cd8bd9123bed570f971fce596a14",
+        ],
+    },
+    resolver: {
+        latest: "941bf87f26cb817f3c6a52a326de855cca8a1dc4477e62a38ec4ffa5c7f43806",
+        superseded: [
+            "cb927ffa19d6b1f3f0b0187048d885e200adb6de3fddd11ee3cfeb59df9c5c48",
+            "351bf4e056b179b578fe2a4ea46f937bfafccc6538c7357ea70021b7038d91ea",
+            "c6dfcd7bbf35943a13406888678334d0938d0fea54939906b00c2dc37b4a9a71",
+            "5e7b4fb8d310d67ed6966a155e748d60be771422b3e8c34bbc14485f98525574",
+        ],
+    },
+};
+export function contractUpgradeDirection(role, currentHash, targetHash) {
+    const { latest, superseded } = CONTRACT_RELEASES[role];
+    if (currentHash === targetHash)
+        return "same";
+    if (superseded.includes(targetHash))
+        return "backward";
+    if (targetHash !== latest)
+        return "unreviewed-target";
+    return superseded.includes(currentHash) ? "forward" : "unrecognized-current";
+}
+export function upgradeHash(hash) {
+    if (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))
+        throw new NativeClaimError("Contract implementation hash must be lowercase hex32");
+    return sc.bytes(Uint8Array.from(hash.match(/../g), value => parseInt(value, 16)));
+}
+/** Independent of claim versions, claim configuration and fee-token policy. */
+export async function contractUpgradeStatus(context, namespace, role, wasmHash) {
+    if (role !== "registrar" && role !== "resolver")
+        throw new NativeClaimError("Unknown namespace contract role");
+    const target = upgradeHash(wasmHash);
+    const node = namespaceNode(namespace), args = [sc.bytes(node)];
+    const [pair, owner, code, registrar, resolver, selected, registrarTainted, resolverTainted] = await Promise.all([
+        context.read(context.registryId, "native_contracts", args),
+        context.read(context.registryId, "owner_of", args),
+        expectedNativeCode(context, hex(node)),
+        context.read(context.registryId, "registrar_of", args),
+        context.read(context.registryId, "attested_resolver_of", args),
+        context.read(context.registryId, "resolver_of", args),
+        context.read(context.registryId, "registrar_tainted", args),
+        context.read(context.registryId, "resolver_tainted", args),
+    ]);
+    const fail = (message) => { throw new NativeClaimError(message, "unavailable"); };
+    if (!Array.isArray(pair) || pair.length !== 2 || pair[0] !== registrar || pair[1] !== resolver || selected !== resolver || registrarTainted !== false || resolverTainted !== false)
+        fail("Namespace contracts are missing, tainted or differ from the Registry's native binding");
+    const registrarId = address(registrar, "contract", "namespace Registrar");
+    const resolverId = address(resolver, "contract", "namespace Resolver");
+    const contractId = role === "registrar" ? registrarId : resolverId;
+    const [registrarInstance, resolverInstance, anchors, provenanceRaw, authority, registry, version] = await Promise.all([
+        context.server.getContractInstance(registrarId),
+        context.server.getContractInstance(resolverId),
+        context.read(registrarId, "anchors", []),
+        context.read(resolverId, "provenance", []),
+        context.read(resolverId, "authority", []),
+        context.read(resolverId, "registry", []),
+        // A verified legacy Registry is safely reported as disallowed without probing a new child ABI.
+        code.governed ? context.read(contractId, "upgrade_policy_version", []) : 0,
+    ]);
+    for (const [instance, expected] of [[registrarInstance, code.registrar], [resolverInstance, code.resolver]]) {
+        if (instance.executable.type !== "contractExecutableWasm" || hex(instance.executable.wasmHash.value) !== expected)
+            fail("Namespace contract executable differs from Registry-approved code");
+    }
+    if (!Array.isArray(anchors) || anchors.length !== 2 || anchors[0] !== context.registryId || hex(bytes32(anchors[1], "Registrar namespace")) !== hex(node))
+        fail("Registrar anchors differ from selected namespace");
+    const provenance = exactObject(provenanceRaw, ["registry", "node"], "Resolver provenance");
+    if (provenance.registry !== context.registryId || hex(bytes32(provenance.node, "Resolver namespace")) !== hex(node) || authority !== registrarId || registry !== context.registryId)
+        fail("Resolver provenance or authority differs from selected namespace");
+    const governed = code.governed && u32(version, "contract upgrade policy") === 1;
+    const approved = code.governed
+        ? bool(await context.read(context.registryId, "implementation_approved", [sc.u32(role === "registrar" ? 0 : 1), target]), "implementation approval")
+        : false;
+    return { owner: address(owner, "identity", "namespace owner"), contractId, currentHash: code[role], approved, governed };
+}

package/dist/subnames-client.d.ts

@@ -0,0 +1,49 @@
+import { type xdr } from "@stellar/stellar-sdk";
+import { type SubnameRecord } from "./names.js";
+export declare const SUBNAME_REGISTRAR_ERRORS: Record<number, string>;
+export declare const subnameLabelArg: (value: string) => xdr.ScVal;
+export declare function subnameParent(input: string): import("./names.js").ParsedResolvableName;
+export declare function subnameParts(input: string): import("./names.js").ParsedResolvableName;
+export declare function createSubnameReader(config: {
+    registryId: string;
+    error?: (message: string) => Error;
+    read: (id: string, fn: string, args: xdr.ScVal[]) => Promise<unknown>;
+}): {
+    context: (input: string) => Promise<{
+        namespace: string;
+        registrar: string;
+        owner: string;
+        policy: import("./names.js").SubnamePolicy;
+    }>;
+    creationContext: (input: string) => Promise<{
+        namespace: string;
+        registrar: string;
+        owner: string;
+        policy: import("./names.js").SubnamePolicy;
+    }>;
+    recordAt: (ctx: Awaited<ReturnType<(input: string) => Promise<{
+        namespace: string;
+        registrar: string;
+        owner: string;
+        policy: import("./names.js").SubnamePolicy;
+    }>>>, parent: string, label: string) => Promise<SubnameRecord | null>;
+    record: (name: string) => Promise<SubnameRecord | null>;
+    policy: (namespace: string) => Promise<import("./names.js").SubnamePolicy>;
+    list: (parent: string, options?: {
+        offset?: number;
+        limit?: number;
+    }) => Promise<{
+        parent: string;
+        policy: import("./names.js").SubnamePolicy;
+        records: {
+            parentNode: Uint8Array;
+            parentGeneration: bigint;
+            generation: bigint;
+            address: string;
+            active: boolean;
+            name: string;
+        }[];
+        offset: number;
+        nextOffset: number | null;
+    }>;
+};

package/dist/subnames-client.js

@@ -0,0 +1,63 @@
+// Generated by sdk/names/sync.mjs; edit sdk/names/subnames-client.ts.
+import { hash, nativeToScVal, StrKey } from "@stellar/stellar-sdk";
+import { parseNamespace, parseResolvableName, resolvableNameNode, subnamePolicyFromNative, subnameRecordFromNative, subnameLabelsFromNative, subnamePageInput } from "./names.js";
+export const SUBNAME_REGISTRAR_ERRORS = { 53: "SubnameCreationDisabled", 54: "SubnamesSuspended", 55: "SubnameGenerationMismatch", 56: "SubnameIndexUnavailable" };
+const account = (value) => typeof value === "string" && (StrKey.isValidEd25519PublicKey(value) || StrKey.isValidContract(value));
+const contract = (value) => typeof value === "string" && StrKey.isValidContract(value);
+export const subnameLabelArg = (value) => nativeToScVal(new TextEncoder().encode(value), { type: "bytes" });
+export function subnameParent(input) { const parsed = parseResolvableName(input); if (parsed.childLabel)
+    throw new Error("parent must be label.namespace"); return parsed; }
+export function subnameParts(input) { const parsed = parseResolvableName(input); if (!parsed.childLabel)
+    throw new Error("subname must be child.label.namespace"); return parsed; }
+export function createSubnameReader(config) {
+    const read = config.read;
+    const failure = (message) => config.error?.(message) ?? new Error(message);
+    async function context(input) {
+        const namespace = parseNamespace(input);
+        if (!contract(config.registryId))
+            throw failure("invalid Registry");
+        const joined = new Uint8Array(64);
+        joined.set(hash(new TextEncoder().encode(namespace)), 32);
+        const node = hash(joined);
+        const arg = nativeToScVal(node, { type: "bytes" });
+        const [registrar, owner] = await Promise.all([read(config.registryId, "registrar_of", [arg]), read(config.registryId, "owner_of", [arg])]);
+        if (!contract(registrar) || !account(owner))
+            throw failure("namespace has no current Registrar or owner");
+        const anchors = await read(registrar, "anchors", []);
+        if (!Array.isArray(anchors) || anchors.length !== 2 || anchors[0] !== config.registryId || !(anchors[1] instanceof Uint8Array) || anchors[1].length !== 32 || !node.every((b, i) => b === anchors[1][i]))
+            throw failure("subname Registrar context mismatch");
+        if (await read(registrar, "subname_version", []) !== 1)
+            throw failure("subnames unsupported");
+        const policy = subnamePolicyFromNative(await read(registrar, "subname_policy", []));
+        return { namespace, registrar, owner, policy };
+    }
+    async function creationContext(input) {
+        const ctx = await context(input), joined = new Uint8Array(64);
+        joined.set(hash(new TextEncoder().encode(ctx.namespace)), 32);
+        const resolver = await read(config.registryId, "resolver_of", [nativeToScVal(hash(joined), { type: "bytes" })]);
+        if (!contract(resolver))
+            throw failure("subnames unsupported: no Resolver");
+        const [anchor, authority, version] = await Promise.all([read(resolver, "registry", []), read(resolver, "authority", []), read(resolver, "subname_version", [])]);
+        if (anchor !== config.registryId || authority !== ctx.registrar)
+            throw failure("subname Resolver context mismatch");
+        if (version !== 1)
+            throw failure("subnames unsupported by Resolver");
+        return ctx;
+    }
+    async function recordAt(ctx, parent, label) {
+        const record = subnameRecordFromNative(await read(ctx.registrar, "subname_record", [subnameLabelArg(parent), subnameLabelArg(label)]), resolvableNameNode(`${parent}.${ctx.namespace}`));
+        if (record && !account(record.address))
+            throw failure("invalid subname destination");
+        return record;
+    }
+    async function record(name) { const parsed = subnameParts(name), ctx = await context(parsed.namespace); return recordAt(ctx, parsed.parentLabel, parsed.childLabel); }
+    async function policy(namespace) { return (await context(namespace)).policy; }
+    async function list(parent, options = {}) {
+        const parsed = subnameParent(parent), { offset, limit } = subnamePageInput(options.offset, options.limit), ctx = await context(parsed.namespace);
+        const labels = subnameLabelsFromNative(await read(ctx.registrar, "subname_labels", [subnameLabelArg(parsed.label), nativeToScVal(offset, { type: "u32" }), nativeToScVal(limit, { type: "u32" })]), limit);
+        const records = await Promise.all(labels.map(async (label) => { const record = await recordAt(ctx, parsed.label, label); if (!record)
+            throw failure("subname index references missing record"); return { name: `${label}.${parsed.name}`, ...record }; }));
+        return { parent: parsed.name, policy: ctx.policy, records, offset, nextOffset: labels.length === limit ? offset + labels.length : null };
+    }
+    return { context, creationContext, recordAt, record, policy, list };
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@sorandomains/owner",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Run your Soran namespace on Stellar: configure claims, issue names and manage namespace policies.",
   "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=22.12.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,7 +16,8 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "tsc",
     "check:browser": "esbuild dist/index.js --bundle --platform=browser --external:@stellar/stellar-sdk --outfile=browser-check.js --legal-comments=none --log-level=error && node -e \"const fs=require('fs');const s=fs.readFileSync('browser-check.js','utf8');fs.unlinkSync('browser-check.js');if(/\\bBuffer\\b/.test(s)){console.error('FAIL: bare Buffer reference in browser bundle');process.exit(1)}console.log('browser bundle clean')\"",
-    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/native-*.test.mts && node --import tsx --test test/funding.test.mts test/funding-history.test.mts"
+    "test": "node --import tsx test/decode-failure.test.mts && node --import tsx --test test/integration.test.mts test/hardening.test.mts test/error-codes.test.mts test/native-*.test.mts && node --import tsx --test test/funding.test.mts test/funding-history.test.mts test/funding-bounds.test.mts && node --import tsx --test test/multichain.test.mts && node --import tsx --test test/subnames.test.mts",
+    "test:hardening": "node --import tsx --test test/hardening.test.mts"
   },
   "license": "MIT",
   "repository": {
@@ -51,5 +52,12 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
+  },
+  "dependencies": {
+    "@noble/hashes": "2.4.0",
+    "@scure/base": "2.4.0"
+  },
+  "overrides": {
+    "axios": "1.20.0"
   }
 }