@x1id/resolve 0.8.0 → 0.10.0

package/dist/agent.js

@@ -192,7 +192,7 @@ export function x402AcceptsFromManifest(manifest, opts) {
     // Mainnet has no such id yet — X1 mainnet doesn't exist — so a manifest
     // claiming network: "mainnet" without its own explicit x402.network gets
     // an honestly-provisional placeholder rather than a fabricated genesis hash.
-    const network = x402?.network ?? (manifest.x1id.network === "testnet" ? X1_TESTNET_NETWORK : "x1:mainnet-unassigned");
+    const network = x402?.network ?? (manifest.x1id.network === "testnet" ? X1_TESTNET_NETWORK : "solana:mainnet-unassigned");
     const payTo = opts?.payTo ?? manifest.payment?.addresses?.[0]?.address;
     return x402Endpoints.map((e) => {
         const hint = {

package/dist/base58.d.ts

@@ -1,3 +1,11 @@
 export declare function encodeBase58(bytes: Uint8Array): string;
+/**
+ * Decode base58 to its exact bytes (standard leading-`1`→leading-zero-byte
+ * handling), or null for a character outside the alphabet. Unlike
+ * {@link decodeBase58_32} this preserves length, so it decodes a 64-byte
+ * ed25519 signature (`signin.ts`) as faithfully as a 32-byte key. Pass
+ * `expectedLen` to reject anything but that length up front.
+ */
+export declare function decodeBase58(s: string, expectedLen?: number): Uint8Array | null;
 /** Decode to exactly 32 bytes, or null if the input is not a valid address. */
 export declare function decodeBase58_32(s: string): Uint8Array | null;

package/dist/base58.js

@@ -16,6 +16,37 @@ export function encodeBase58(bytes) {
     }
     return out === "" ? "1" : out;
 }
+/**
+ * Decode base58 to its exact bytes (standard leading-`1`→leading-zero-byte
+ * handling), or null for a character outside the alphabet. Unlike
+ * {@link decodeBase58_32} this preserves length, so it decodes a 64-byte
+ * ed25519 signature (`signin.ts`) as faithfully as a 32-byte key. Pass
+ * `expectedLen` to reject anything but that length up front.
+ */
+export function decodeBase58(s, expectedLen) {
+    if (s.length === 0)
+        return null;
+    let zeros = 0;
+    while (zeros < s.length && s[zeros] === "1")
+        zeros++;
+    let n = 0n;
+    for (const c of s) {
+        const i = A.indexOf(c);
+        if (i === -1)
+            return null;
+        n = n * 58n + BigInt(i);
+    }
+    const tail = [];
+    while (n > 0n) {
+        tail.unshift(Number(n & 255n));
+        n >>= 8n;
+    }
+    const out = new Uint8Array(zeros + tail.length);
+    out.set(tail, zeros);
+    if (expectedLen !== undefined && out.length !== expectedLen)
+        return null;
+    return out;
+}
 /** Decode to exactly 32 bytes, or null if the input is not a valid address. */
 export function decodeBase58_32(s) {
     if (s.length === 0 || s.length > 44)

package/dist/domainProof.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Independent, re-verifiable domain->wallet proof via DNS-over-HTTPS (#8318,
+ * Approach C — the "auditable attestor" honesty upgrade).
+ *
+ * # Why this exists
+ *
+ * A `dns`-kind {@link import("./attestation.js").HandleAttestation} records only
+ * that x1id's admin-rotatable attestor key *signed off* on an off-chain DNS
+ * lookup ("attestation.ts" says this plainly): the chain stores the attestor's
+ * say-so, not a proof. The fully-trustless answers (an on-chain DNSSEC verifier,
+ * or a zkTLS proof — Approaches A/B in `docs/trustless-domain-proof-plan.md`)
+ * are BLOCKED on this X1 fork because the runtime does not have the crypto
+ * primitives they need active (`big_mod_exp` / `secp256r1` / `alt_bn128` are all
+ * feature-gated off). Until one of those lands, this module is the shippable
+ * middle ground: it lets ANYONE independently re-resolve the domain's DNS record
+ * and confirm the binding, so the attestor can no longer lie *undetected*. Trust
+ * moves from "the x1id attestor" to "DNS + the domain owner" — a real, cheap
+ * upgrade that needs no on-chain change.
+ *
+ * It is dependency-free and runs in both the browser and Node: a DoH query is a
+ * plain HTTPS GET, and the JSON shape ("application/dns-json", the Cloudflare /
+ * Google convention) is parsed by hand, like the rest of this package.
+ *
+ * # The TXT record convention (the interoperability contract)
+ *
+ * A domain owner proves control of `<domain>` by publishing a TXT record at the
+ * name **`_x1id.<domain>`** whose value is:
+ *
+ *     x1id-wallet=<base58 wallet pubkey>
+ *
+ * - The prefix is the exported {@link TXT_BINDING_PREFIX} (`x1id-wallet=`).
+ * - `<base58 wallet pubkey>` is the 32-byte X1/SVM wallet address, base58, that
+ *   the domain is bound to (the handle's authority wallet). Multiple TXT records
+ *   under the same name are allowed — a domain may bind more than one wallet
+ *   (e.g. during a key rotation); {@link resolveDomainBinding} returns them all.
+ * - A single TXT record split into several character-strings (RFC 1035 §3.3.14 /
+ *   RFC 7208 §3.3) is concatenated with no separator before the prefix is
+ *   matched, exactly as a mail SPF/DKIM verifier would.
+ *
+ * This is the contract a domain owner follows, so it is deliberately simple and
+ * stable. It mirrors the `_dnslink`/`_atproto`/`_domainkey` underscore-prefixed
+ * convention rather than putting x1id data on the apex TXT (which would collide
+ * with SPF/verification tokens from every other service).
+ *
+ * # NOTE — the paired attestor-side follow-up (NOT done here)
+ *
+ * This SDK-only change gives verifiers the re-check primitive. The *other* half
+ * of Approach C — having the attestor publish the exact `_x1id.<domain>` TXT it
+ * checked inside the attestation's `evidence_hash` preimage bundle, so a
+ * back-dated attestation whose TXT was later removed is still disprovable — is a
+ * change to the admin-api attest tooling (`tools/`), tracked as a FOLLOW-UP. See
+ * `docs/trustless-domain-proof-plan.md` §4. Until that ships,
+ * {@link verifyDomainBinding} can only confirm a binding that is *still live* in
+ * DNS; it cannot audit a removed one.
+ */
+import type { RpcFn } from "./accounts.js";
+/** The canonical prefix of the `_x1id.<domain>` TXT binding value. A TXT string
+ *  that (after character-string concatenation) starts with this, followed by a
+ *  valid base58 32-byte address, is an x1id binding record. */
+export declare const TXT_BINDING_PREFIX = "x1id-wallet=";
+/** The DNS label prefixed to a domain to locate its x1id binding TXT records —
+ *  the query name is `${TXT_NAME_PREFIX}.<domain>`. */
+export declare const TXT_NAME_PREFIX = "_x1id";
+/** Built-in DoH endpoints (both speak the `application/dns-json` shape). */
+declare const DOH_PROVIDERS: Readonly<{
+    readonly cloudflare: "https://cloudflare-dns.com/dns-query";
+    readonly google: "https://dns.google/resolve";
+}>;
+export interface DomainProofOptions {
+    /** Which built-in DoH provider to use when {@link dohUrl} is not given.
+     *  Default `"cloudflare"`. */
+    readonly provider?: keyof typeof DOH_PROVIDERS;
+    /** A full DoH endpoint base URL (overrides {@link provider}), e.g. a
+     *  self-hosted resolver. The query string (`?name=...&type=TXT`) is appended;
+     *  a URL that already has query params is respected (`&` is used). Must speak
+     *  the `application/dns-json` response shape. */
+    readonly dohUrl?: string;
+    /** `fetch` override — inject one in tests (return canned DoH JSON) or to use a
+     *  custom transport. Defaults to `globalThis.fetch`. */
+    readonly fetchImpl?: typeof fetch;
+    /** Abort the DoH request after this many ms. Default 6000. */
+    readonly timeoutMs?: number;
+}
+/** The outcome of resolving a domain's `_x1id` TXT bindings. `ok` is about the
+ *  LOOKUP succeeding, not about any wallet being found: a domain that simply has
+ *  no binding is `ok: true` with an empty `wallets`. `ok: false` means the DNS
+ *  query itself failed (network, timeout, DoH error) and the answer is unknown —
+ *  never a throw. */
+export interface DomainBindingResult {
+    /** The DNS lookup completed and its answer was parsed. */
+    readonly ok: boolean;
+    /** The domain queried (lowercased, canonical). */
+    readonly domain: string;
+    /** Every distinct wallet the `_x1id.<domain>` TXT records bind, base58
+     *  (canonical spelling), first-seen order, de-duplicated. Empty when the
+     *  domain publishes no valid binding (or when `ok` is false). */
+    readonly wallets: string[];
+    /** Why the lookup failed, or a note when it succeeded with nothing usable.
+     *  Absent on a clean success that found bindings. */
+    readonly reason?: string;
+}
+/**
+ * Resolve the wallet(s) a domain binds via its `_x1id.<domain>` TXT records,
+ * independently of x1id's attestor — a DoH GET, parsed and validated defensively.
+ *
+ * Never throws: a network failure, timeout, or malformed answer comes back as
+ * `{ ok: false, reason }`; a domain with no binding as `{ ok: true, wallets: [] }`.
+ */
+export declare function resolveDomainBinding(domain: string, opts?: DomainProofOptions): Promise<DomainBindingResult>;
+/** The outcome of checking a domain against an expected wallet. */
+export interface VerifyDomainBindingResult {
+    /** True iff the domain's `_x1id` TXT binds `expectedWallet` and the lookup
+     *  succeeded. */
+    readonly ok: boolean;
+    /** Every wallet the domain binds (base58, canonical) — for context/UX even on
+     *  a mismatch. Empty on a lookup failure. */
+    readonly found: string[];
+    /** Why `ok` is false: `"invalid-domain"` / `"invalid-wallet"` for bad inputs,
+     *  a DoH failure reason (`"timeout"`, `"network-error"`, ...), `"not-found"`
+     *  when the domain publishes no binding, or `"mismatch"` when it binds other
+     *  wallets but not the expected one. Absent when `ok` is true. */
+    readonly reason?: string;
+}
+/**
+ * The core "anyone can check it" primitive: does `<domain>` independently bind
+ * `expectedWallet` in DNS? Returns `{ ok, found, reason? }` and never throws.
+ *
+ * A verifier calling this trusts DNS and the domain owner — NOT x1id's attestor.
+ */
+export declare function verifyDomainBinding(domain: string, expectedWallet: string, opts?: DomainProofOptions): Promise<VerifyDomainBindingResult>;
+/** The combined on-chain-attestation + live-DNS check. */
+export interface VerifyDomainAttestationResult {
+    /** Both halves hold: x1id attested the domain (a non-stale `dns` attestation)
+     *  AND DNS still independently confirms the binding. This is the strongest
+     *  signal this SDK can give for a domain today. */
+    readonly ok: boolean;
+    /** The handle holds a NON-STALE `dns`-kind attestation for the current owner
+     *  ("x1id attested it"). */
+    readonly attested: boolean;
+    /** DNS independently confirms the binding right now ("still current, attestor
+     *  couldn't have lied"). */
+    readonly dnsConfirmed: boolean;
+    /** The wallet(s) the domain currently binds in DNS. */
+    readonly found: string[];
+    /** A note when `ok` is false — e.g. `"attestation-error"` if the chain read
+     *  threw, or the {@link verifyDomainBinding} reason for the DNS half. */
+    readonly reason?: string;
+}
+/**
+ * Convenience: confirm BOTH that x1id attested a domain AND that DNS still
+ * independently backs it up — so a caller learns not just "x1id says so" but
+ * "and it's verifiably still true", closing the attestor's ability to have lied.
+ *
+ * `registeredAt` / `recordsClearedAt` are the owning Handle's fields the caller
+ * already decoded (see {@link import("./accounts.js").parseHandleAccount}); they
+ * are MANDATORY here for the same reason every attestation read demands them —
+ * the staleness rule (`attested_at >= registered_at`, and `>= records_cleared_at`)
+ * decides whether an attestation vouches for the *current* owner at all. The
+ * two halves are evaluated independently, so a caller can see which one holds:
+ * a chain-read failure does not suppress the DNS answer, and vice-versa.
+ *
+ * Never throws: a failed chain read degrades to `attested: false` with
+ * `reason: "attestation-error"`, mirroring `signin.ts`'s best-effort summary.
+ */
+export declare function verifyDomainAttestation(rpc: RpcFn, programId: string, handleAccount: string, registeredAt: bigint, recordsClearedAt: bigint, domain: string, expectedWallet: string, opts?: DomainProofOptions): Promise<VerifyDomainAttestationResult>;
+export {};

package/dist/domainProof.js

@@ -0,0 +1,278 @@
+/**
+ * Independent, re-verifiable domain->wallet proof via DNS-over-HTTPS (#8318,
+ * Approach C — the "auditable attestor" honesty upgrade).
+ *
+ * # Why this exists
+ *
+ * A `dns`-kind {@link import("./attestation.js").HandleAttestation} records only
+ * that x1id's admin-rotatable attestor key *signed off* on an off-chain DNS
+ * lookup ("attestation.ts" says this plainly): the chain stores the attestor's
+ * say-so, not a proof. The fully-trustless answers (an on-chain DNSSEC verifier,
+ * or a zkTLS proof — Approaches A/B in `docs/trustless-domain-proof-plan.md`)
+ * are BLOCKED on this X1 fork because the runtime does not have the crypto
+ * primitives they need active (`big_mod_exp` / `secp256r1` / `alt_bn128` are all
+ * feature-gated off). Until one of those lands, this module is the shippable
+ * middle ground: it lets ANYONE independently re-resolve the domain's DNS record
+ * and confirm the binding, so the attestor can no longer lie *undetected*. Trust
+ * moves from "the x1id attestor" to "DNS + the domain owner" — a real, cheap
+ * upgrade that needs no on-chain change.
+ *
+ * It is dependency-free and runs in both the browser and Node: a DoH query is a
+ * plain HTTPS GET, and the JSON shape ("application/dns-json", the Cloudflare /
+ * Google convention) is parsed by hand, like the rest of this package.
+ *
+ * # The TXT record convention (the interoperability contract)
+ *
+ * A domain owner proves control of `<domain>` by publishing a TXT record at the
+ * name **`_x1id.<domain>`** whose value is:
+ *
+ *     x1id-wallet=<base58 wallet pubkey>
+ *
+ * - The prefix is the exported {@link TXT_BINDING_PREFIX} (`x1id-wallet=`).
+ * - `<base58 wallet pubkey>` is the 32-byte X1/SVM wallet address, base58, that
+ *   the domain is bound to (the handle's authority wallet). Multiple TXT records
+ *   under the same name are allowed — a domain may bind more than one wallet
+ *   (e.g. during a key rotation); {@link resolveDomainBinding} returns them all.
+ * - A single TXT record split into several character-strings (RFC 1035 §3.3.14 /
+ *   RFC 7208 §3.3) is concatenated with no separator before the prefix is
+ *   matched, exactly as a mail SPF/DKIM verifier would.
+ *
+ * This is the contract a domain owner follows, so it is deliberately simple and
+ * stable. It mirrors the `_dnslink`/`_atproto`/`_domainkey` underscore-prefixed
+ * convention rather than putting x1id data on the apex TXT (which would collide
+ * with SPF/verification tokens from every other service).
+ *
+ * # NOTE — the paired attestor-side follow-up (NOT done here)
+ *
+ * This SDK-only change gives verifiers the re-check primitive. The *other* half
+ * of Approach C — having the attestor publish the exact `_x1id.<domain>` TXT it
+ * checked inside the attestation's `evidence_hash` preimage bundle, so a
+ * back-dated attestation whose TXT was later removed is still disprovable — is a
+ * change to the admin-api attest tooling (`tools/`), tracked as a FOLLOW-UP. See
+ * `docs/trustless-domain-proof-plan.md` §4. Until that ships,
+ * {@link verifyDomainBinding} can only confirm a binding that is *still live* in
+ * DNS; it cannot audit a removed one.
+ */
+import { decodeBase58_32, encodeBase58 } from "./base58.js";
+import { fetchAttestations } from "./attestation.js";
+import { attestationsPassGate, GateKind } from "./gate.js";
+/** The canonical prefix of the `_x1id.<domain>` TXT binding value. A TXT string
+ *  that (after character-string concatenation) starts with this, followed by a
+ *  valid base58 32-byte address, is an x1id binding record. */
+export const TXT_BINDING_PREFIX = "x1id-wallet=";
+/** The DNS label prefixed to a domain to locate its x1id binding TXT records —
+ *  the query name is `${TXT_NAME_PREFIX}.<domain>`. */
+export const TXT_NAME_PREFIX = "_x1id";
+/** DoH JSON `type` code for a TXT record (RFC 1035). */
+const DNS_TYPE_TXT = 16;
+/** Built-in DoH endpoints (both speak the `application/dns-json` shape). */
+const DOH_PROVIDERS = Object.freeze({
+    cloudflare: "https://cloudflare-dns.com/dns-query",
+    google: "https://dns.google/resolve",
+});
+const DEFAULT_TIMEOUT_MS = 6000;
+/** A domain is a case-insensitive dotted hostname (1..253 chars, labels 1..63 of
+ *  `[a-z0-9-]`, no leading/trailing hyphen). Strict enough that the name can be
+ *  safely interpolated into a query and can never smuggle a second query param. */
+const DOMAIN_RE = /^(?=.{1,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/;
+function normalizeDomain(domain) {
+    if (typeof domain !== "string")
+        return null;
+    // Tolerate a trailing dot (fully-qualified form) and case; reject everything
+    // else so the name is safe to interpolate into the query.
+    const d = domain.trim().replace(/\.$/, "").toLowerCase();
+    if (!DOMAIN_RE.test(d))
+        return null;
+    return d;
+}
+function buildDohUrl(base, name) {
+    const q = `name=${encodeURIComponent(name)}&type=TXT`;
+    return base.includes("?") ? `${base}&${q}` : `${base}?${q}`;
+}
+/**
+ * Concatenate a DoH TXT `data` field into its logical string.
+ *
+ * DoH returns a TXT record's RDATA as its character-strings, each wrapped in
+ * double quotes; a record split into several character-strings comes back as
+ * several quoted runs (e.g. `"\"x1id-ver\" \"ification=...\""`). Per RFC 1035
+ * §3.3.14 they concatenate with NO separator. Escaped `\"` and `\\` inside a
+ * run are unescaped. A `data` with no quotes at all (some resolvers) is used
+ * verbatim.
+ */
+function unquoteTxtData(data) {
+    if (!data.includes('"'))
+        return data;
+    let out = "";
+    let inStr = false;
+    for (let i = 0; i < data.length; i++) {
+        const c = data[i];
+        if (!inStr) {
+            if (c === '"')
+                inStr = true;
+            // characters between quoted runs (whitespace) are dropped
+            continue;
+        }
+        if (c === "\\") {
+            // escaped char: take the next byte literally
+            const next = data[i + 1];
+            if (next !== undefined) {
+                out += next;
+                i++;
+            }
+            continue;
+        }
+        if (c === '"') {
+            inStr = false;
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+/** Extract a canonical base58 wallet from one concatenated TXT string, or null
+ *  if it is not a well-formed x1id binding. */
+function walletFromTxt(txt) {
+    if (!txt.startsWith(TXT_BINDING_PREFIX))
+        return null;
+    const raw = txt.slice(TXT_BINDING_PREFIX.length).trim();
+    const bytes = decodeBase58_32(raw);
+    if (!bytes)
+        return null;
+    // Re-encode so a non-canonical base58 spelling and the caller's wallet compare
+    // byte-for-byte, exactly like the rest of the SDK does.
+    return encodeBase58(bytes);
+}
+async function fetchDohJson(url, fetchImpl, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(url, {
+            signal: controller.signal,
+            // Cloudflare's /dns-query REQUIRES this to return JSON; harmless for Google.
+            headers: { accept: "application/dns-json" },
+        });
+        if (!res.ok)
+            return { ok: false, reason: `doh-http-${res.status}` };
+        const json = (await res.json());
+        return { ok: true, json };
+    }
+    catch (e) {
+        const reason = e?.name === "AbortError" ? "timeout" : "network-error";
+        return { ok: false, reason };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Resolve the wallet(s) a domain binds via its `_x1id.<domain>` TXT records,
+ * independently of x1id's attestor — a DoH GET, parsed and validated defensively.
+ *
+ * Never throws: a network failure, timeout, or malformed answer comes back as
+ * `{ ok: false, reason }`; a domain with no binding as `{ ok: true, wallets: [] }`.
+ */
+export async function resolveDomainBinding(domain, opts) {
+    const canonical = normalizeDomain(domain);
+    if (canonical === null) {
+        return { ok: false, domain: String(domain), wallets: [], reason: "invalid-domain" };
+    }
+    const fetchImpl = opts?.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+        return { ok: false, domain: canonical, wallets: [], reason: "no-fetch" };
+    }
+    const base = opts?.dohUrl ?? DOH_PROVIDERS[opts?.provider ?? "cloudflare"];
+    const url = buildDohUrl(base, `${TXT_NAME_PREFIX}.${canonical}`);
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const res = await fetchDohJson(url, fetchImpl, timeoutMs);
+    if (!res.ok)
+        return { ok: false, domain: canonical, wallets: [], reason: res.reason };
+    const body = res.json;
+    if (typeof body !== "object" || body === null) {
+        return { ok: false, domain: canonical, wallets: [], reason: "malformed-response" };
+    }
+    const b = body;
+    const status = typeof b.Status === "number" ? b.Status : -1;
+    // 0 = NOERROR (parse answers), 3 = NXDOMAIN (the name simply doesn't exist =
+    // no binding, a clean empty result). Anything else (SERVFAIL, etc.) is an
+    // unknown answer, not a proven absence.
+    if (status === 3)
+        return { ok: true, domain: canonical, wallets: [] };
+    if (status !== 0)
+        return { ok: false, domain: canonical, wallets: [], reason: `doh-status-${status}` };
+    const answers = Array.isArray(b.Answer) ? b.Answer : [];
+    const wallets = [];
+    for (const ans of answers) {
+        if (typeof ans !== "object" || ans === null)
+            continue;
+        const a = ans;
+        if (a.type !== DNS_TYPE_TXT)
+            continue; // skip CNAME/other chained answers
+        if (typeof a.data !== "string")
+            continue;
+        const wallet = walletFromTxt(unquoteTxtData(a.data));
+        if (wallet && !wallets.includes(wallet))
+            wallets.push(wallet);
+    }
+    return { ok: true, domain: canonical, wallets };
+}
+/**
+ * The core "anyone can check it" primitive: does `<domain>` independently bind
+ * `expectedWallet` in DNS? Returns `{ ok, found, reason? }` and never throws.
+ *
+ * A verifier calling this trusts DNS and the domain owner — NOT x1id's attestor.
+ */
+export async function verifyDomainBinding(domain, expectedWallet, opts) {
+    const wanted = typeof expectedWallet === "string" ? decodeBase58_32(expectedWallet) : null;
+    if (!wanted)
+        return { ok: false, found: [], reason: "invalid-wallet" };
+    const wantedBase58 = encodeBase58(wanted);
+    const res = await resolveDomainBinding(domain, opts);
+    if (!res.ok)
+        return { ok: false, found: [], reason: res.reason ?? "lookup-failed" };
+    if (res.wallets.length === 0)
+        return { ok: false, found: [], reason: "not-found" };
+    if (!res.wallets.includes(wantedBase58)) {
+        return { ok: false, found: res.wallets, reason: "mismatch" };
+    }
+    return { ok: true, found: res.wallets };
+}
+/**
+ * Convenience: confirm BOTH that x1id attested a domain AND that DNS still
+ * independently backs it up — so a caller learns not just "x1id says so" but
+ * "and it's verifiably still true", closing the attestor's ability to have lied.
+ *
+ * `registeredAt` / `recordsClearedAt` are the owning Handle's fields the caller
+ * already decoded (see {@link import("./accounts.js").parseHandleAccount}); they
+ * are MANDATORY here for the same reason every attestation read demands them —
+ * the staleness rule (`attested_at >= registered_at`, and `>= records_cleared_at`)
+ * decides whether an attestation vouches for the *current* owner at all. The
+ * two halves are evaluated independently, so a caller can see which one holds:
+ * a chain-read failure does not suppress the DNS answer, and vice-versa.
+ *
+ * Never throws: a failed chain read degrades to `attested: false` with
+ * `reason: "attestation-error"`, mirroring `signin.ts`'s best-effort summary.
+ */
+export async function verifyDomainAttestation(rpc, programId, handleAccount, registeredAt, recordsClearedAt, domain, expectedWallet, opts) {
+    // Half 1 (on-chain): a non-stale dns attestation for the current owner. A
+    // read failure must not sink the DNS half — degrade, never throw.
+    let attested = false;
+    let attestationReason;
+    try {
+        const attestations = await fetchAttestations(rpc, programId, handleAccount, registeredAt, recordsClearedAt);
+        attested = attestationsPassGate(attestations, { kind: GateKind.dns });
+    }
+    catch {
+        attestationReason = "attestation-error";
+    }
+    // Half 2 (off-chain, independent): DNS still binds the expected wallet.
+    const dns = await verifyDomainBinding(domain, expectedWallet, opts);
+    const ok = attested && dns.ok;
+    const reason = ok ? undefined : (attestationReason ?? (attested ? dns.reason : "not-attested"));
+    return {
+        ok,
+        attested,
+        dnsConfirmed: dns.ok,
+        found: dns.found,
+        ...(reason !== undefined ? { reason } : {}),
+    };
+}

package/dist/gate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Attestation-gated allowlists (#8316) — gate access to your app by whether an
+ * `@handle` holds a verified on-chain attestation (any signal, or a SPECIFIC
+ * platform like "verified GitHub"). A project reuses X1ID's blue-tick oracle as
+ * its allowlist instead of running its own KYC.
+ *
+ * The gate operates on the attestations {@link fetchAttestations} returns; the
+ * staleness rule (an attestation only counts for the CURRENT owner —
+ * `attested_at >= handle.registered_at`) is already baked into `HandleAttestation.stale`,
+ * and this module always ignores stale ones. Nothing here trusts an off-chain
+ * claim: every input is an on-chain, attestor-signed `Attestation` account.
+ */
+import { type HandleAttestation } from "./attestation.js";
+import type { RpcFn } from "./accounts.js";
+/** What a handle must prove to pass the gate:
+ *  - `"any-verified"` — at least one non-stale attestation of any kind.
+ *  - `{ kind }` — a non-stale attestation of exactly that kind.
+ *  - `{ anyOf }` — a non-stale attestation of any listed kind (e.g. X OR GitHub). */
+export type Gate = "any-verified" | {
+    readonly kind: number;
+} | {
+    readonly anyOf: readonly number[];
+};
+/** Named platform kinds, re-exported so callers gate without magic numbers. */
+export declare const GateKind: {
+    readonly dns: 0;
+    readonly social: 1;
+    readonly x: 2;
+    readonly discord: 3;
+    readonly github: 4;
+    readonly telegram: 5;
+};
+/** Pure check: do these (already-fetched) attestations satisfy the gate?
+ *  Stale attestations never count. */
+export declare function attestationsPassGate(attestations: readonly HandleAttestation[], gate: Gate): boolean;
+/** Fetch a handle's attestations and test the gate in one call. `handleAccount`,
+ *  `registeredAt` and `recordsClearedAt` come from the handle you resolved
+ *  (name → `deriveHandleAccount` → decode). Returns the pass/fail plus the
+ *  attestations so a caller can also render WHICH signals matched. */
+export declare function handlePassesGate(rpc: RpcFn, programId: string, handleAccount: string, registeredAt: bigint, recordsClearedAt: bigint, gate: Gate): Promise<{
+    readonly passed: boolean;
+    readonly attestations: HandleAttestation[];
+}>;

package/dist/gate.js

@@ -0,0 +1,38 @@
+/**
+ * Attestation-gated allowlists (#8316) — gate access to your app by whether an
+ * `@handle` holds a verified on-chain attestation (any signal, or a SPECIFIC
+ * platform like "verified GitHub"). A project reuses X1ID's blue-tick oracle as
+ * its allowlist instead of running its own KYC.
+ *
+ * The gate operates on the attestations {@link fetchAttestations} returns; the
+ * staleness rule (an attestation only counts for the CURRENT owner —
+ * `attested_at >= handle.registered_at`) is already baked into `HandleAttestation.stale`,
+ * and this module always ignores stale ones. Nothing here trusts an off-chain
+ * claim: every input is an on-chain, attestor-signed `Attestation` account.
+ */
+import { fetchAttestations, isHandleVerified, ATTESTATION_KIND_DNS, ATTESTATION_KIND_SOCIAL, ATTESTATION_KIND_X, ATTESTATION_KIND_DISCORD, ATTESTATION_KIND_GITHUB, ATTESTATION_KIND_TELEGRAM, } from "./attestation.js";
+/** Named platform kinds, re-exported so callers gate without magic numbers. */
+export const GateKind = {
+    dns: ATTESTATION_KIND_DNS,
+    social: ATTESTATION_KIND_SOCIAL,
+    x: ATTESTATION_KIND_X,
+    discord: ATTESTATION_KIND_DISCORD,
+    github: ATTESTATION_KIND_GITHUB,
+    telegram: ATTESTATION_KIND_TELEGRAM,
+};
+/** Pure check: do these (already-fetched) attestations satisfy the gate?
+ *  Stale attestations never count. */
+export function attestationsPassGate(attestations, gate) {
+    if (gate === "any-verified")
+        return isHandleVerified(attestations);
+    const kinds = "kind" in gate ? [gate.kind] : gate.anyOf;
+    return attestations.some((a) => !a.stale && kinds.includes(a.kind));
+}
+/** Fetch a handle's attestations and test the gate in one call. `handleAccount`,
+ *  `registeredAt` and `recordsClearedAt` come from the handle you resolved
+ *  (name → `deriveHandleAccount` → decode). Returns the pass/fail plus the
+ *  attestations so a caller can also render WHICH signals matched. */
+export async function handlePassesGate(rpc, programId, handleAccount, registeredAt, recordsClearedAt, gate) {
+    const attestations = await fetchAttestations(rpc, programId, handleAccount, registeredAt, recordsClearedAt);
+    return { passed: attestationsPassGate(attestations, gate), attestations };
+}

package/dist/index.d.ts

@@ -27,13 +27,14 @@
 export * from "./types.js";
 export { normalizeHandle, parseName, looksLikeName, type ParsedName } from "./parse.js";
 export { WasmResolver, type WasmTld } from "./wasm.js";
-export { encodeBase58, decodeBase58_32 } from "./base58.js";
+export { encodeBase58, decodeBase58, decodeBase58_32 } from "./base58.js";
 export { decodeRecord, liveRecords, chainForCoinType, valueToAddress, fetchRecords, RECORD_LEN, RECORD_DISC, type HandleRecord, } from "./records.js";
 export { buildControlChallenge, parseControlChallenge, generateControlNonce, createControlChallenge, verifyControlProof, verifyEd25519Strict, CONTROL_CHALLENGE_PREFIX, type ControlChallenge, type ControlConfig, type ControlProof, type ControlVerification, type ControlFailureReason, } from "./control.js";
 export * from "./delegate.js";
 export * from "./subname.js";
 export * from "./recordCount.js";
 export * from "./attestation.js";
+export * from "./gate.js";
 export * from "./textRecords.js";
 export * from "./lock.js";
 export * from "./integrator.js";
@@ -46,6 +47,8 @@ export * from "./recordWrite.js";
 export * from "./clearRecords.js";
 export * from "./commitReveal.js";
 export * from "./pnftTransfer.js";
+export * from "./signin.js";
+export * from "./domainProof.js";
 import { type Chain, type Resolved } from "./types.js";
 import { WasmResolver } from "./wasm.js";
 import { type HandleRecord } from "./records.js";

package/dist/index.js

@@ -27,13 +27,14 @@
 export * from "./types.js";
 export { normalizeHandle, parseName, looksLikeName } from "./parse.js";
 export { WasmResolver } from "./wasm.js";
-export { encodeBase58, decodeBase58_32 } from "./base58.js";
+export { encodeBase58, decodeBase58, decodeBase58_32 } from "./base58.js";
 export { decodeRecord, liveRecords, chainForCoinType, valueToAddress, fetchRecords, RECORD_LEN, RECORD_DISC, } from "./records.js";
 export { buildControlChallenge, parseControlChallenge, generateControlNonce, createControlChallenge, verifyControlProof, verifyEd25519Strict, CONTROL_CHALLENGE_PREFIX, } from "./control.js";
 export * from "./delegate.js";
 export * from "./subname.js";
 export * from "./recordCount.js";
 export * from "./attestation.js";
+export * from "./gate.js";
 export * from "./textRecords.js";
 export * from "./lock.js";
 export * from "./integrator.js";
@@ -53,6 +54,8 @@ export * from "./recordWrite.js";
 export * from "./clearRecords.js";
 export * from "./commitReveal.js";
 export * from "./pnftTransfer.js";
+export * from "./signin.js";
+export * from "./domainProof.js";
 import { ResolveError, CHAIN_COIN_TYPE } from "./types.js";
 import { parseName } from "./parse.js";
 import { encodeBase58, decodeBase58_32 } from "./base58.js";

package/dist/signin.d.ts

@@ -0,0 +1,318 @@
+/**
+ * "Sign in with X1ID" — a client-side, wallet-signature proof of @handle
+ * ownership (WP #8313). An OAuth-style login *primitive*, framework-agnostic,
+ * that any third-party app can drop in to let a user authenticate as their
+ * `@handle`.
+ *
+ * # What this is — and, honestly, what it is not
+ *
+ * X1ID's app is a static export and `@x1id/resolve` is a pure client library:
+ * there is **no server-side token exchange** here. This module is therefore
+ * the SIWE-style ("Sign-In With Ethereum", EIP-4361) shape adapted to X1:
+ *
+ *   1. the relying app builds a **domain-bound** challenge naming the wallet,
+ *      a fresh nonce, an issued-at and an expiry ({@link createSignInChallenge});
+ *   2. the wallet signs the raw UTF-8 bytes of that challenge (ed25519 — X1 and
+ *      Solana share the curve and key format);
+ *   3. the relying app verifies the signature ({@link verifySignIn}) and then
+ *      reverse-resolves the address to its primary `@handle` and verification
+ *      summary ({@link resolveIdentity}).
+ *
+ * A single verified sign-in proves exactly: **"this wallet, which *currently*
+ * owns @handle, signed this challenge for this domain, before it expired."** It
+ * is NOT a session and NOT a bearer token — the relying app MUST bind the
+ * verified identity to its own session (a cookie, a JWT it mints, ...). And
+ * handle ownership can change (a sale, a transfer, `clear_primary`), so a long-
+ * lived session should re-run {@link resolveIdentity} periodically rather than
+ * trust a handle captured at login forever.
+ *
+ * A full hosted OAuth *authorization-code server* (real token issuance, a
+ * `/authorize` + `/token` pair, refresh tokens) needs a backend and is
+ * deliberately **out of scope** — see the README's "What needs a server".
+ *
+ * # Reuse, not reinvention
+ *
+ * - Signature verification is the SDK's existing RFC-8032-strict
+ *   {@link import("./control.js").verifyEd25519Strict} (WebCrypto Ed25519),
+ *   the same primitive the control-proof flow relies on. No new crypto.
+ * - Identity resolution is the SDK's own {@link import("./index.js").createResolver}
+ *   `reverse()` (with all its staleness/authority trust rules) plus
+ *   {@link import("./attestation.js").fetchAttestations} — never a re-derived
+ *   PDA or a hand-rolled ownership check.
+ *
+ * # Cross-protocol separation
+ *
+ * A sign-in challenge is always a MULTI-LINE SIWE block (it contains `\n`).
+ * The record-verification challenge (`x1-handles:v1:...`) and the control-proof
+ * challenge (`x1-handles:ctl:v1:...`) are both single lines with no newline, so
+ * a signature obtained for one can never validate as another — the byte spaces
+ * are structurally disjoint.
+ */
+/** Why a verification or a convenience sign-in failed. Mirrors `ResolveError`'s
+ *  code-not-string style so a UI can branch on the cause. */
+export type SignInFailureReason = 
+/** The challenge string is not a well-formed sign-in challenge. */
+"invalid-challenge"
+/** The signature is malformed (not base58, or not 64 bytes). */
+ | "invalid-signature"
+/** The address argument is not a valid base58 X1 address. */
+ | "invalid-address"
+/** The address argument does not match the address bound in the challenge. */
+ | "address-mismatch"
+/** An `expectedDomain` was given and does not match the challenge's domain. */
+ | "domain-mismatch"
+/** An `expectedNonce` was given and does not match the challenge's nonce. */
+ | "nonce-mismatch"
+/** `now` is before the challenge's issued-at (minus skew) — clock problem
+ *  or a challenge minted for the future. */
+ | "not-yet-valid"
+/** `now` is past the challenge's expiry (plus skew). Replay window closed. */
+ | "expired"
+/** The signature does not verify over the challenge bytes for this address. */
+ | "bad-signature";
+/** Codes a thrown {@link SignInError} carries — every {@link SignInFailureReason}
+ *  plus the convenience-flow-only outcomes. */
+export type SignInErrorCode = SignInFailureReason | "no-handle" | "wallet-error" | "invalid-params";
+/**
+ * Thrown by {@link signInWithX1ID} (the convenience flow) and by the argument
+ * validation in {@link createSignInChallenge}. Pure verification via
+ * {@link verifySignIn} does NOT throw for a verification outcome — it returns
+ * `{ ok: false, reason }` — this class is for the throw-based login call.
+ */
+export declare class SignInError extends Error {
+    readonly code: SignInErrorCode;
+    readonly cause?: unknown | undefined;
+    constructor(code: SignInErrorCode, message: string, cause?: unknown | undefined);
+}
+export interface SignInChallengeParams {
+    /** The relying party's domain, e.g. `"app.example.com"`. Bound into the
+     *  challenge; a signature for one domain never validates for another. */
+    readonly domain: string;
+    /** The X1 wallet address (base58) that will sign. Bound into the challenge so
+     *  a signature cannot be lifted onto a different account's session. */
+    readonly address: string;
+    /** Optional human-readable statement shown to the user in their wallet. Single
+     *  line only (a newline would corrupt the challenge structure). */
+    readonly statement?: string;
+    /** Resource URI. Defaults to `https://<domain>`. */
+    readonly uri?: string;
+    /** Single-use nonce. Generated ({@link generateSignInNonce}) when omitted. */
+    readonly nonce?: string;
+    /** Issued-at, ms since epoch. Defaults to `Date.now()`. */
+    readonly issuedAt?: number;
+    /** Lifetime in seconds from issued-at. Defaults to 300 (5 minutes). */
+    readonly expiresInSec?: number;
+}
+/** A built challenge: the exact string to sign, plus its parsed fields for the
+ *  relying party to store (nonce single-use, expiry enforcement are the RP's). */
+export interface SignInChallenge {
+    /** The exact string whose raw UTF-8 bytes the wallet signs. */
+    readonly challenge: string;
+    readonly domain: string;
+    readonly address: string;
+    readonly uri: string;
+    readonly statement: string | null;
+    readonly nonce: string;
+    /** Issued-at, ms since epoch. */
+    readonly issuedAt: number;
+    /** Expiry, ms since epoch. */
+    readonly expiresAt: number;
+}
+/**
+ * Generate a single-use sign-in nonce: `bytes` bytes (>= 8) from the platform
+ * CSPRNG, hex-encoded to stay inside the nonce charset. SINGLE-USE — the
+ * relying party stores it with the issued challenge and rejects a second proof
+ * against it (client-side code cannot enforce single use; the RP must).
+ */
+export declare function generateSignInNonce(bytes?: number): string;
+/**
+ * Build a deterministic, human-readable SIWE-style sign-in challenge.
+ *
+ * The exact bytes signed are the UTF-8 encoding of this string (no wallet
+ * prefix — the wallet's `signMessage` signs the message as given):
+ *
+ *     <domain> wants you to sign in with your X1 account:
+ *     <address>
+ *
+ *     <statement>            ← omitted, with its blank line, when no statement
+ *
+ *     URI: <uri>
+ *     Version: 1
+ *     Chain: X1
+ *     Nonce: <nonce>
+ *     Issued At: <ISO-8601>
+ *     Expiration Time: <ISO-8601>
+ *
+ * @throws {SignInError} `invalid-params` for a bad domain, address, statement,
+ * nonce, or time.
+ */
+export declare function createSignInChallenge(params: SignInChallengeParams): SignInChallenge;
+/** The fields recovered from a challenge string. */
+export interface ParsedSignInChallenge {
+    readonly domain: string;
+    readonly address: string;
+    readonly uri: string;
+    readonly statement: string | null;
+    readonly nonce: string;
+    readonly issuedAt: number;
+    readonly expiresAt: number;
+}
+/**
+ * Parse a sign-in challenge string back to its fields, or null for anything
+ * that is not one — including a record-verification or control-proof challenge
+ * (both single-line, so they fail the header match). This is a pure structural
+ * parse; it proves nothing about the signature.
+ */
+export declare function parseSignInChallenge(challenge: string): ParsedSignInChallenge | null;
+export interface VerifySignInParams {
+    /** The challenge string the wallet signed (built by {@link createSignInChallenge}). */
+    readonly challenge: string;
+    /** The address that supposedly signed, base58. Must match the challenge's. */
+    readonly address: string;
+    /** The 64-byte ed25519 signature, base58-encoded (what a wallet's
+     *  `signMessage` output looks like once base58'd, the common wire form). */
+    readonly signatureBase58: string;
+    /** If given, require the challenge's domain to equal this — the relying
+     *  party's own domain. Strongly recommended: it turns the signed-in domain
+     *  binding into an *enforced* check against phishing. */
+    readonly expectedDomain?: string;
+    /** If given, require the challenge's nonce to equal this — the nonce the RP
+     *  issued and is about to burn. */
+    readonly expectedNonce?: string;
+    /** `Date.now()` override, ms — for tests and deterministic demos. */
+    readonly now?: number;
+    /** Allowed clock skew in seconds for issued-at/expiry. Default 60. */
+    readonly clockSkewSec?: number;
+    /** Ed25519 verifier override for runtimes whose WebCrypto lacks Ed25519.
+     *  Defaults to the SDK's RFC-8032-strict {@link verifyEd25519Strict}. */
+    readonly verifyEd25519?: (publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => Promise<boolean>;
+}
+export type SignInVerification = {
+    readonly ok: true;
+    /** The verified signer, base58 (canonical spelling). */
+    readonly address: string;
+    readonly domain: string;
+    readonly nonce: string;
+    readonly issuedAt: number;
+    readonly expiresAt: number;
+} | {
+    readonly ok: false;
+    readonly reason: SignInFailureReason;
+    readonly message: string;
+};
+/**
+ * Verify a sign-in proof: the signature is a valid ed25519 signature over the
+ * exact challenge bytes for `address`, the address is the one bound in the
+ * challenge, and `now` is inside `[issuedAt, expiresAt]` (± skew). Optionally
+ * enforces `expectedDomain` / `expectedNonce`.
+ *
+ * Verification outcomes come back as `{ ok: false, reason }` — this function
+ * never throws for one. It does NOT touch the chain: it proves only that the
+ * wallet signed. Whether that wallet currently owns a handle is a separate,
+ * on-chain question answered by {@link resolveIdentity}.
+ *
+ * Replay protection is nonce + expiry, and both need the relying party: pass
+ * `expectedNonce` (and never accept the same nonce twice), and keep the expiry
+ * window short. The domain binding needs `expectedDomain` to become a check.
+ */
+export declare function verifySignIn(params: VerifySignInParams): Promise<SignInVerification>;
+/** One live "verified by [platform]" signal on the signed-in handle. */
+export interface IdentityVerification {
+    /** Platform slug (`"x"`, `"discord"`, `"github"`, `"telegram"`) or the legacy
+     *  `"dns"` / `"social"` kind names, or null for a kind this SDK does not know. */
+    readonly platform: string | null;
+    /** Raw attestation kind byte. */
+    readonly kind: number;
+    /** Unix seconds the attestation was (last) stamped. */
+    readonly attestedAt: number;
+}
+/** The friendly identity behind an address. */
+export interface ResolvedIdentity {
+    /** The address resolved, base58 (canonical). */
+    readonly address: string;
+    /** The address's primary `@handle` (canonical, no `@`), or null when it has
+     *  no trustworthy handle primary. An X1NS-only primary comes back as null
+     *  here — this is the @handle identity surface. */
+    readonly handle: string | null;
+    /** Ready-to-render label: `@<handle>` or null. */
+    readonly display: string | null;
+    /** Whether the handle carries at least one LIVE verification (the blue-tick
+     *  condition, #7145). False when there is no handle. Trust caveat: a true
+     *  means x1id's rotatable attestor key vouched for an off-chain review — read
+     *  it as "verified by x1id", not trustless proof. */
+    readonly verified: boolean;
+    /** The live verifications, if any. */
+    readonly verifications: readonly IdentityVerification[];
+}
+export interface IdentityConfig {
+    /** X1 RPC endpoint. */
+    readonly rpcUrl: string;
+    /** The WASM resolver the app already loaded (needed for PDA derivation). */
+    readonly wasm: import("./wasm.js").WasmResolver;
+    /** Optional fetch override for testing or custom transport. */
+    readonly fetchImpl?: typeof fetch;
+    /** @handle registry program id. Defaults to the canonical X1 deployment. */
+    readonly handleProgramId?: string;
+    /** Resolver cache TTL in ms (passed through to `createResolver`). */
+    readonly cacheTtlMs?: number;
+}
+/**
+ * Reverse-resolve an address to its primary `@handle` and verification summary.
+ *
+ * Reuses the SDK's own `createResolver().reverse()` — with every staleness and
+ * current-authority rule it enforces — for the handle, then
+ * {@link import("./attestation.js").fetchAttestations} for the "verified by"
+ * summary, read with the same epoch/`records_cleared_at` staleness rule the
+ * rest of the SDK applies. Nothing here re-derives a PDA or re-checks ownership
+ * by hand.
+ *
+ * @throws {import("./types.js").ResolveError} `rpc-error` for transport
+ * problems (a handle with no primary is not an error — `handle` is null).
+ */
+export declare function resolveIdentity(cfg: IdentityConfig, address: string): Promise<ResolvedIdentity>;
+export interface SignInWithX1IDParams extends IdentityConfig {
+    /** The connected wallet's `signMessage`: signs the raw message bytes and
+     *  returns the 64-byte ed25519 signature. Matches the X1ID app's wallet
+     *  adapter (`app/src/lib/wallet` normalizes every provider to this shape). */
+    readonly signMessage: (message: Uint8Array) => Promise<Uint8Array>;
+    /** The connected wallet's address, base58 — known from wallet-connect before
+     *  signing, bound into the challenge and used to verify. */
+    readonly address: string;
+    /** The relying party's domain. */
+    readonly domain: string;
+    readonly statement?: string;
+    readonly uri?: string;
+    readonly nonce?: string;
+    readonly issuedAt?: number;
+    readonly expiresInSec?: number;
+    /** Throw `no-handle` when the wallet has no primary @handle. Default true —
+     *  "Sign in with X1ID" implies an X1ID. Set false to allow handle-less
+     *  sign-in (returns `handle: null`). */
+    readonly requireHandle?: boolean;
+    readonly clockSkewSec?: number;
+    readonly now?: number;
+    readonly verifyEd25519?: VerifySignInParams["verifyEd25519"];
+}
+export interface SignInIdentity extends ResolvedIdentity {
+    /** The exact challenge that was signed — store it with the session if you
+     *  want an audit trail of what the user agreed to. */
+    readonly challenge: string;
+    readonly nonce: string;
+    readonly issuedAt: number;
+    readonly expiresAt: number;
+}
+/**
+ * The whole flow in one call: build a domain-bound challenge, have the wallet
+ * sign it, verify the signature, and resolve the address to its `@handle`
+ * identity. Returns the resolved identity on success.
+ *
+ * The relying party still owns the *session*: bind the returned identity to
+ * your own session and re-check ownership periodically — this call proves the
+ * signature at THIS moment, nothing longer-lived.
+ *
+ * @throws {SignInError} `wallet-error` if the wallet rejects/fails signing, a
+ * verification `SignInFailureReason` code if the signature does not verify, or
+ * `no-handle` when `requireHandle` (default) and the wallet has no primary
+ * handle.
+ */
+export declare function signInWithX1ID(params: SignInWithX1IDParams): Promise<SignInIdentity>;

package/dist/x402.d.ts

@@ -14,19 +14,26 @@
  * 2026-09-22 — NOT invented. See `docs/x402.md` for the full design,
  * including what's explicitly OUT of scope here (a facilitator).
  *
- * # The one x1id-specific choice: the network identifier
+ * # The network identifier — CAIP-30, for OSS interop (#8325)
  *
- * x402's Solana networks use `"solana:<genesis-hash>"` (CAIP-2-shaped). X1
- * is SVM-compatible but its OWN chain — not Solana — so it gets its own
- * namespace under the identical convention: `"x1:<genesis-hash>"`. This is
- * NOT an x402-foundation-registered network; it's a principled extension of
- * their own pattern to a new SVM-compatible chain, not a claim of official
- * support. {@link X1_TESTNET_NETWORK} is the live testnet genesis hash,
- * verified against `getGenesisHash` 2026-09-22.
+ * x402's SVM networks use `"solana:<first-32-of-genesis>"` (CAIP-30: the
+ * `solana:` namespace + the first 32 base58 chars of the genesis hash). X1 is
+ * its own SVM chain, but `@x402/core`'s reference client/facilitator only route
+ * the `solana:*` scheme family — so to let ANY standard, unmodified x402 client
+ * or wallet pay an x1id agent out of the box, X1 testnet uses the CAIP-30 form
+ * keyed on X1's genesis. (Fortiswap's self-hosted X1 facilitator uses the
+ * identical id.) An earlier release used a principled `"x1:<full-genesis>"`
+ * extension; it was OSS-incompatible, so this migrated to CAIP-30 —
+ * {@link X1_LEGACY_TESTNET_NETWORK} is kept only for reading older manifests.
+ * Verified against `getGenesisHash` (full hash
+ * `C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho`).
  */
-/** X1 testnet's x402 network identifier (`"x1:<genesis-hash>"`, verified
- *  live 2026-09-22 via `getGenesisHash`). */
-export declare const X1_TESTNET_NETWORK = "x1:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho";
+/** X1 testnet's x402 network id — CAIP-30 `"solana:" + first 32 chars of the
+ *  genesis hash — so unmodified OSS x402 clients route to it (#8325). */
+export declare const X1_TESTNET_NETWORK = "solana:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWw";
+/** The pre-#8325 `"x1:<full-genesis>"` id. DEPRECATED — kept only so a reader
+ *  can still recognise manifests published before the CAIP-30 migration. */
+export declare const X1_LEGACY_TESTNET_NETWORK = "x1:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho";
 /** The x402 scheme x1id implements — "exact": pay a fixed amount of a named
  *  asset to a named recipient. (x402 also defines "upto" for usage-based
  *  pricing; not implemented here.) */

package/dist/x402.js

@@ -14,19 +14,26 @@
  * 2026-09-22 — NOT invented. See `docs/x402.md` for the full design,
  * including what's explicitly OUT of scope here (a facilitator).
  *
- * # The one x1id-specific choice: the network identifier
+ * # The network identifier — CAIP-30, for OSS interop (#8325)
  *
- * x402's Solana networks use `"solana:<genesis-hash>"` (CAIP-2-shaped). X1
- * is SVM-compatible but its OWN chain — not Solana — so it gets its own
- * namespace under the identical convention: `"x1:<genesis-hash>"`. This is
- * NOT an x402-foundation-registered network; it's a principled extension of
- * their own pattern to a new SVM-compatible chain, not a claim of official
- * support. {@link X1_TESTNET_NETWORK} is the live testnet genesis hash,
- * verified against `getGenesisHash` 2026-09-22.
+ * x402's SVM networks use `"solana:<first-32-of-genesis>"` (CAIP-30: the
+ * `solana:` namespace + the first 32 base58 chars of the genesis hash). X1 is
+ * its own SVM chain, but `@x402/core`'s reference client/facilitator only route
+ * the `solana:*` scheme family — so to let ANY standard, unmodified x402 client
+ * or wallet pay an x1id agent out of the box, X1 testnet uses the CAIP-30 form
+ * keyed on X1's genesis. (Fortiswap's self-hosted X1 facilitator uses the
+ * identical id.) An earlier release used a principled `"x1:<full-genesis>"`
+ * extension; it was OSS-incompatible, so this migrated to CAIP-30 —
+ * {@link X1_LEGACY_TESTNET_NETWORK} is kept only for reading older manifests.
+ * Verified against `getGenesisHash` (full hash
+ * `C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho`).
  */
-/** X1 testnet's x402 network identifier (`"x1:<genesis-hash>"`, verified
- *  live 2026-09-22 via `getGenesisHash`). */
-export const X1_TESTNET_NETWORK = "x1:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho";
+/** X1 testnet's x402 network id — CAIP-30 `"solana:" + first 32 chars of the
+ *  genesis hash — so unmodified OSS x402 clients route to it (#8325). */
+export const X1_TESTNET_NETWORK = "solana:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWw";
+/** The pre-#8325 `"x1:<full-genesis>"` id. DEPRECATED — kept only so a reader
+ *  can still recognise manifests published before the CAIP-30 migration. */
+export const X1_LEGACY_TESTNET_NETWORK = "x1:C7ucgdDEhxLTpXHhWSZxavSVmaNTUJWwT5iTdeaviDho";
 /** The x402 scheme x1id implements — "exact": pay a fixed amount of a named
  *  asset to a named recipient. (x402 also defines "upto" for usage-based
  *  pricing; not implemented here.) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x1id/resolve",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Resolve @handles and X1NS names on X1. Never silently picks between namespaces.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "build": "tsc -p tsconfig.json",
     "test": "node --test test/*.test.js",
     "lint:package": "publint",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "cargo build --release -p x1-resolve-wasm --target wasm32-unknown-unknown --manifest-path ../Cargo.toml && node ../web/verify-wasm.mjs wasm/x1_resolve_wasm.wasm ../target/wasm32-unknown-unknown/release/x1_resolve_wasm.wasm && npm run build"
   },
   "keywords": [
     "x1",
@@ -59,12 +59,5 @@
     "@solana/web3.js": {
       "optional": true
     }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/fortiblox/x1id-sdk.git"
-  },
-  "bugs": {
-    "url": "https://x1id.io"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Fortiblox
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.