@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/esm/identity/seedIdentity.js

@@ -1,453 +0,0 @@
-import { validateMnemonic, mnemonicToSeedSync } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { pubECDSA, pubSchnorr } from "@scure/btc-signer/utils.js";
-import { SigHash } from "@scure/btc-signer";
-import { hex } from "@scure/base";
-import { TreeSignerSession } from "../tree/signingSession.js";
-import { schnorr, signAsync } from "@noble/secp256k1";
-import { HDKey, expand, networks, scriptExpressions, } from "@bitcoinerlab/descriptors-scure";
-import { descriptorIsOurs, isMainnetDescriptor } from "./descriptor.js";
-const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
-/**
- * Secret-bearing state for seed-backed identities, held off the public
- * instance surface. Accessed only by the SDK-internal serializer helpers
- * below; application code cannot read these via ordinary field access.
- *
- * Using a module-private WeakMap (rather than `private` / `protected`)
- * matters because TypeScript visibility is a compile-time boundary only:
- * JavaScript consumers could still read public fields. A WeakMap removes
- * that enumeration path entirely.
- */
-const seedBytes = new WeakMap();
-const mnemonicMeta = new WeakMap();
-/**
- * Seed-based identity derived from a raw seed and an account descriptor
- * *template*.
- *
- * This is the recommended identity type for most applications. It uses
- * standard BIP86 (Taproot) derivation by default; callers that need a
- * different path supply the wildcard template directly.
- *
- * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
- * integrations — `SingleKey` exists for backward compatibility with
- * raw nsec-style keys.
- *
- * The identity holds the wildcard *template* (e.g.
- * `tr([fp/86'/0'/0']xpub/0/*)`) on its public {@link descriptor}
- * field. HD rotation reads it directly; consumers that need a
- * concrete descriptor at a specific index materialize it themselves
- * (see `HDDescriptorProvider` in the wallet layer).
- *
- * Exposes seed-level primitives (signing, derivation, the template)
- * but is deliberately NOT a `DescriptorProvider`. Wrap it explicitly
- * to get one:
- *  - `HDDescriptorProvider` for rotating receive addresses.
- *  - {@link StaticDescriptorProvider} for legacy, single-key behaviour.
- *
- * The split prevents a SeedIdentity from being silently used as a
- * concrete descriptor source, which would defeat HD rotation without
- * any compile-time signal that something was wrong.
- *
- * @example
- * ```typescript
- * const seed = mnemonicToSeedSync(mnemonic);
- *
- * // Testnet (BIP86 wildcard descriptor m/86'/1'/0'/0/*)
- * const identity = SeedIdentity.fromSeed(seed, { isMainnet: false });
- *
- * // Mainnet (BIP86 wildcard descriptor m/86'/0'/0'/0/*)
- * const identity = SeedIdentity.fromSeed(seed, { isMainnet: true });
- *
- * // Caller-supplied wildcard descriptor (must end in `/*)`).
- * const identity = SeedIdentity.fromSeed(seed, { descriptor });
- * ```
- */
-export class SeedIdentity {
-    /**
-     * Constructs a SeedIdentity from a 64-byte seed and either a
-     * caller-supplied wildcard descriptor (`{ descriptor }`) or the
-     * default BIP86 path at the requested network (`{ isMainnet }`).
-     * Prefer the {@link fromSeed} factory for symmetry with
-     * {@link MnemonicIdentity.fromMnemonic}.
-     *
-     * Throws on a non-wildcard descriptor, an xpub mismatch with the
-     * seed, or a missing derivation path.
-     */
-    constructor(seed, opts = {}) {
-        if (seed.length !== 64) {
-            throw new Error("Seed must be 64 bytes");
-        }
-        // Resolve the descriptor: caller-supplied wins; otherwise build
-        // the BIP86 default at the requested network via the library.
-        let descriptor;
-        let network;
-        if ("descriptor" in opts && typeof opts.descriptor === "string") {
-            descriptor = opts.descriptor;
-            network = isMainnetDescriptor(descriptor)
-                ? networks.bitcoin
-                : networks.testnet;
-        }
-        else {
-            network =
-                (opts.isMainnet ?? true)
-                    ? networks.bitcoin
-                    : networks.testnet;
-            descriptor = scriptExpressions.trBIP32({
-                masterNode: HDKey.fromMasterSeed(seed, network.bip32),
-                network,
-                account: 0,
-                change: 0,
-                index: "*",
-            });
-        }
-        // Parse the descriptor, substituting the wildcard at index 0.
-        // The library raises "index passed for non-ranged descriptor"
-        // if the input isn't a wildcard template, which we re-wrap so
-        // the caller sees what they actually got wrong.
-        let expansion;
-        try {
-            expansion = expand({ descriptor, network, index: 0 });
-        }
-        catch (e) {
-            throw new Error(`SeedIdentity requires a wildcard descriptor template (must end in "/*)"); ${e instanceof Error ? e.message : String(e)}`);
-        }
-        const keyInfo = expansion.expansionMap?.["@0"];
-        // Defensive copy: `derivedKey` and `descriptor` are computed eagerly
-        // from the bytes we're about to stash, so a later mutation of the
-        // caller's buffer must not drift the serialized `seed` out of sync
-        // with the live identity state.
-        seedBytes.set(this, new Uint8Array(seed));
-        this.descriptor = descriptor;
-        if (!keyInfo?.originPath) {
-            throw new Error("Descriptor must include a key origin path");
-        }
-        // Verify the xpub in the descriptor matches our seed (validates
-        // that the descriptor was generated from this seed; we don't
-        // need to keep the xpub around afterwards — `isOurs` re-derives
-        // it from `this.descriptor` on demand).
-        const masterNode = HDKey.fromMasterSeed(seed, network.bip32);
-        const accountNode = masterNode.derive(`m${keyInfo.originPath}`);
-        if (accountNode.publicExtendedKey !== keyInfo.bip32?.toBase58()) {
-            throw new Error("xpub mismatch: derived key does not match descriptor");
-        }
-        // Derive the private key for index 0 using the full path
-        if (!keyInfo.path) {
-            throw new Error("Descriptor must specify a full derivation path");
-        }
-        const derivedNode = masterNode.derive(keyInfo.path);
-        if (!derivedNode.privateKey) {
-            throw new Error("Failed to derive private key");
-        }
-        this.derivedKey = derivedNode.privateKey;
-    }
-    /**
-     * Creates a SeedIdentity from a raw 64-byte seed.
-     *
-     * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a caller-supplied account-descriptor
-     * template (the option's value must end with `/*)`).
-     *
-     * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
-     * @param opts - Network selection or descriptor template.
-     */
-    static fromSeed(seed, opts = {}) {
-        return new SeedIdentity(seed, opts);
-    }
-    async xOnlyPublicKey() {
-        return pubSchnorr(this.derivedKey);
-    }
-    async compressedPublicKey() {
-        return pubECDSA(this.derivedKey, true);
-    }
-    async sign(tx, inputIndexes) {
-        return this.signTxWithKey(tx, this.derivedKey, inputIndexes);
-    }
-    async signMessage(message, signatureType = "schnorr") {
-        return this.signMessageWithKey(this.derivedKey, message, signatureType);
-    }
-    signerSession() {
-        return TreeSignerSession.random();
-    }
-    /**
-     * Converts to a watch-only identity that cannot sign. Carries the
-     * template forward, so the readonly side stays HD-capable (can
-     * derive descriptors at any index without seed access).
-     */
-    async toReadonly() {
-        return ReadonlyDescriptorIdentity.fromDescriptor(this.descriptor);
-    }
-    /**
-     * Returns true when `descriptor` is derived from this identity's seed.
-     * HD descriptors match by account xpub; bare `tr(pubkey)` descriptors
-     * match by raw pubkey. See {@link descriptorIsOurs}.
-     */
-    isOurs(descriptor) {
-        return descriptorIsOurs(descriptor, this.descriptor, pubSchnorr(this.derivedKey));
-    }
-    /**
-     * Signs each request with the key derived from its descriptor.
-     * Each descriptor must share this identity's seed ({@link isOurs}).
-     */
-    async signWithDescriptor(requests) {
-        return requests.map((request) => {
-            if (!this.isOurs(request.descriptor)) {
-                throw new Error(`Descriptor ${request.descriptor} does not belong to this identity`);
-            }
-            const key = this.derivePrivateKeyForDescriptor(request.descriptor);
-            return this.signTxWithKey(request.tx, key, request.inputIndexes);
-        });
-    }
-    /**
-     * Signs a message with the key derived from `descriptor`.
-     */
-    async signMessageWithDescriptor(descriptor, message, signatureType = "schnorr") {
-        if (!this.isOurs(descriptor)) {
-            throw new Error(`Descriptor ${descriptor} does not belong to this identity`);
-        }
-        const key = this.derivePrivateKeyForDescriptor(descriptor);
-        return this.signMessageWithKey(key, message, signatureType);
-    }
-    // ── internal helpers ─────────────────────────────────────────────
-    derivePrivateKeyForDescriptor(descriptor) {
-        const network = isMainnetDescriptor(descriptor)
-            ? networks.bitcoin
-            : networks.testnet;
-        const expansion = expand({ descriptor, network });
-        if (expansion.isRanged) {
-            throw new Error("Cannot sign with a wildcard descriptor; derive a concrete index first");
-        }
-        const keyInfo = expansion.expansionMap?.["@0"];
-        if (!keyInfo?.path) {
-            throw new Error("Descriptor must specify a full derivation path for signing");
-        }
-        const seed = seedBytes.get(this);
-        if (!seed) {
-            throw new Error("Seed bytes not available for descriptor signing");
-        }
-        const masterNode = HDKey.fromMasterSeed(seed, network.bip32);
-        const node = masterNode.derive(keyInfo.path);
-        if (!node.privateKey) {
-            throw new Error("Failed to derive private key for descriptor");
-        }
-        return node.privateKey;
-    }
-    signTxWithKey(tx, key, inputIndexes) {
-        const txCpy = tx.clone();
-        if (!inputIndexes) {
-            try {
-                if (!txCpy.sign(key, ALL_SIGHASH)) {
-                    throw new Error("Failed to sign transaction");
-                }
-            }
-            catch (e) {
-                if (e instanceof Error &&
-                    e.message.includes("No inputs signed")) {
-                    // ignore
-                }
-                else {
-                    throw e;
-                }
-            }
-        }
-        else {
-            for (const idx of inputIndexes) {
-                if (!txCpy.signIdx(key, idx, ALL_SIGHASH)) {
-                    throw new Error(`Failed to sign input #${idx}`);
-                }
-            }
-        }
-        return txCpy;
-    }
-    signMessageWithKey(key, message, signatureType) {
-        if (signatureType === "ecdsa")
-            return signAsync(message, key, { prehash: false });
-        return schnorr.signAsync(message, key);
-    }
-}
-/**
- * Mnemonic-based identity derived from a BIP39 phrase.
- *
- * This is the most user-friendly identity type — recommended for wallet
- * applications where users manage their own backup phrase. Extends
- * @see SeedIdentity with mnemonic validation and optional passphrase
- * support.
- *
- * @example
- * ```typescript
- * const identity = MnemonicIdentity.fromMnemonic(
- *   'abandon abandon abandon ...',
- *   { isMainnet: true, passphrase: 'secret' }
- * );
- * ```
- */
-export class MnemonicIdentity extends SeedIdentity {
-    constructor(phrase, opts) {
-        const { passphrase } = opts;
-        super(mnemonicToSeedSync(phrase, passphrase), opts);
-        mnemonicMeta.set(this, { mnemonic: phrase, passphrase });
-    }
-    /**
-     * Creates a MnemonicIdentity from a BIP39 mnemonic phrase.
-     *
-     * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a caller-supplied account-descriptor
-     * template (the option's value must end with `/*)`).
-     *
-     * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
-     * @param opts - Network selection or descriptor template, plus optional passphrase
-     */
-    static fromMnemonic(phrase, opts = {}) {
-        if (!validateMnemonic(phrase, wordlist)) {
-            throw new Error("Invalid mnemonic");
-        }
-        return new MnemonicIdentity(phrase, opts);
-    }
-}
-/**
- * Watch-only HD identity from a descriptor *template*.
- *
- * Can derive public keys but cannot sign transactions. Use this for
- * watch-only wallets — given just an xpub-based template, the readonly
- * side still rotates through HD indices.
- *
- * Constructed from a wildcard template (e.g.
- * `tr([fp/86'/0'/0']xpub.../0/*)`); the {@link descriptor} field
- * holds it for HD providers to consume.
- *
- * @example
- * ```typescript
- * const ro = ReadonlyDescriptorIdentity.fromDescriptor(
- *   "tr([fp/86'/0'/0']xpub.../0/*)"
- * );
- * ro.descriptor;
- * // => "tr([fp/86'/0'/0']xpub.../0/*)" — the template
- * ```
- */
-export class ReadonlyDescriptorIdentity {
-    constructor(descriptor) {
-        const network = isMainnetDescriptor(descriptor)
-            ? networks.bitcoin
-            : networks.testnet;
-        // Library substitutes the wildcard at index 0 and raises
-        // "index passed for non-ranged descriptor" if `descriptor` isn't
-        // actually a wildcard template — re-wrap so the caller sees
-        // the higher-level invariant they violated.
-        let expansion;
-        try {
-            expansion = expand({ descriptor, network, index: 0 });
-        }
-        catch (e) {
-            throw new Error(`ReadonlyDescriptorIdentity requires a wildcard descriptor template (must end in "/*)"); ${e instanceof Error ? e.message : String(e)}`);
-        }
-        const keyInfo = expansion.expansionMap?.["@0"];
-        if (!keyInfo?.pubkey) {
-            throw new Error("Failed to derive public key from descriptor");
-        }
-        if (!keyInfo.bip32) {
-            throw new Error("Cannot determine compressed public key parity from descriptor");
-        }
-        this.descriptor = descriptor;
-        this.indexZero = keyInfo;
-    }
-    /**
-     * Creates a ReadonlyDescriptorIdentity from an account-descriptor
-     * *template* (must end with the BIP-32 wildcard suffix `/*)`).
-     *
-     * @param descriptor - Wildcard-suffixed Taproot template
-     *   (`tr([fp/path']xpub.../child/*)`).
-     */
-    static fromDescriptor(descriptor) {
-        return new ReadonlyDescriptorIdentity(descriptor);
-    }
-    async xOnlyPublicKey() {
-        // Validated non-null in the constructor.
-        return this.indexZero.pubkey;
-    }
-    async compressedPublicKey() {
-        const { bip32, keyPath } = this.indexZero;
-        // bip32 validated non-null in the constructor; derivePath
-        // returns a fresh node so this is a read of the index-0
-        // compressed pubkey, not a mutation of the stored one.
-        if (keyPath) {
-            // Strip leading "/" — the library's derivePath prepends "m/" itself
-            return bip32.derivePath(keyPath.replace(/^\//, "")).publicKey;
-        }
-        return bip32.publicKey;
-    }
-    /**
-     * Returns true when `descriptor` derives from this identity's xpub.
-     * HD descriptors match by account xpub; bare `tr(pubkey)` descriptors
-     * fall back to comparing against the index-0 x-only pubkey. See
-     * {@link descriptorIsOurs}.
-     */
-    isOurs(descriptor) {
-        return descriptorIsOurs(descriptor, this.descriptor, this.indexZero.pubkey);
-    }
-}
-/**
- * Serialize a seed-backed signing identity into a
- * {@link SerializedSigningIdentity} envelope without exposing the
- * underlying secret material on the public instance surface.
- *
- * Called by {@link serializeSigningIdentity}; application code should
- * prefer that public dispatcher instead of calling this directly. This
- * helper is deliberately kept out of the `src/identity` barrel so it is
- * not part of the package's public export surface.
- *
- * Secret-surface trade-off: the resulting envelope carries master-seed
- * material — the BIP39 mnemonic (+ optional passphrase) for
- * `MnemonicIdentity` or the raw 64-byte seed for `SeedIdentity`. A party
- * that reads this envelope can derive any key under the HD tree, not
- * just the key currently in use. The pre-change `SingleKey` flow only
- * shipped one derived private key and therefore had a smaller blast
- * radius. This is an intentional design trade to preserve class and
- * descriptor identity across the page / service-worker boundary; the
- * page already holds the same material so that it can re-initialize a
- * killed worker. Transport is same-origin `postMessage` only. See the
- * threat-model note in `src/worker/browser/README.md`.
- *
- * @internal
- */
-export function serializeSeedOwnedSigningIdentity(identity) {
-    if (identity instanceof MnemonicIdentity) {
-        const meta = mnemonicMeta.get(identity);
-        if (!meta) {
-            throw new Error("MnemonicIdentity is missing internal secret state; was it constructed via MnemonicIdentity.fromMnemonic()?");
-        }
-        const envelope = {
-            type: "mnemonic",
-            mnemonic: meta.mnemonic,
-            descriptor: identity.descriptor,
-        };
-        if (meta.passphrase !== undefined) {
-            envelope.passphrase = meta.passphrase;
-        }
-        return envelope;
-    }
-    const seed = seedBytes.get(identity);
-    if (!seed) {
-        throw new Error("SeedIdentity is missing internal secret state; was it constructed via SeedIdentity.fromSeed() or the class constructor?");
-    }
-    return {
-        type: "seed",
-        seed: hex.encode(seed),
-        descriptor: identity.descriptor,
-    };
-}
-/**
- * Downgrade a seed-backed or descriptor-backed identity into a readonly
- * descriptor envelope. Always produces a descriptor-only shape — secret
- * material never crosses this path, even if the input is a signing
- * identity.
- *
- * Deliberately kept out of the `src/identity` barrel; consumers should go
- * through {@link serializeReadonlyIdentity}.
- *
- * @internal
- */
-export function serializeSeedOwnedReadonlyIdentity(identity) {
-    return {
-        type: "readonly-descriptor",
-        descriptor: identity.descriptor,
-    };
-}

package/dist/esm/identity/serialize.js

@@ -1,164 +0,0 @@
-import { hex } from "@scure/base";
-import { SingleKey, ReadonlySingleKey } from "./singleKey.js";
-import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, serializeSeedOwnedSigningIdentity, serializeSeedOwnedReadonlyIdentity, } from "./seedIdentity.js";
-/** Type guard — true for signing envelopes, false for readonly envelopes. */
-export function isSigningSerialized(s) {
-    return (s.type === "single-key" || s.type === "seed" || s.type === "mnemonic");
-}
-function hasToHex(identity) {
-    return typeof identity.toHex === "function";
-}
-/**
- * Serialize a signing identity into a structured-clone safe envelope for
- * transport across the service-worker boundary.
- *
- * Supports SDK-owned signing identities directly. For custom identities, a
- * duck-typed `toHex()` fallback preserves compatibility with existing
- * `SingleKey`-like implementations.
- */
-export function serializeSigningIdentity(identity) {
-    // Seed-backed identities (including MnemonicIdentity, which extends
-    // SeedIdentity) delegate to the colocated helper so secret material
-    // stays behind the WeakMap-backed internal state in seedIdentity.ts.
-    if (identity instanceof SeedIdentity) {
-        return serializeSeedOwnedSigningIdentity(identity);
-    }
-    if (identity instanceof SingleKey) {
-        return { type: "single-key", privateKey: identity.toHex() };
-    }
-    if (hasToHex(identity)) {
-        return { type: "single-key", privateKey: identity.toHex() };
-    }
-    throw new Error("Unsupported signing identity: cannot serialize for service-worker transport");
-}
-/**
- * Serialize a readonly identity into a structured-clone safe envelope.
- *
- * Works for any `ReadonlyIdentity` via `compressedPublicKey()`. When called
- * with a signing identity, produces a readonly envelope (never ships signing
- * material) — callers that need to preserve signing capability across the
- * boundary must use {@link serializeSigningIdentity}.
- */
-export async function serializeReadonlyIdentity(identity) {
-    if (identity instanceof SeedIdentity ||
-        identity instanceof ReadonlyDescriptorIdentity) {
-        return serializeSeedOwnedReadonlyIdentity(identity);
-    }
-    return {
-        type: "readonly-single-key",
-        publicKey: hex.encode(await identity.compressedPublicKey()),
-    };
-}
-/**
- * Rehydrate a serialized identity envelope back into an identity instance.
- * The return type is the union of signing and readonly; use
- * {@link isSigningSerialized} on the envelope before hydration if the caller
- * needs to know which side it ends up on.
- *
- * Envelopes store the wildcard template directly (see
- * `serializeSeedOwnedSigningIdentity` / `serializeSeedOwnedReadonlyIdentity`),
- * so the `descriptor` field is passed straight through to the
- * template-only factories.
- */
-export function hydrateIdentity(s) {
-    switch (s.type) {
-        case "single-key":
-            return SingleKey.fromHex(s.privateKey);
-        case "readonly-single-key":
-            return ReadonlySingleKey.fromPublicKey(hex.decode(s.publicKey));
-        case "seed":
-            return SeedIdentity.fromSeed(hex.decode(s.seed), {
-                descriptor: s.descriptor,
-            });
-        case "mnemonic":
-            return MnemonicIdentity.fromMnemonic(s.mnemonic, {
-                descriptor: s.descriptor,
-                passphrase: s.passphrase,
-            });
-        case "readonly-descriptor":
-            return ReadonlyDescriptorIdentity.fromDescriptor(s.descriptor);
-        default:
-            // Belt-and-suspenders: `normalizeSerializedIdentity` already
-            // rejects unknown `type` values at the wire boundary. Without
-            // this throw, an unknown type would fall through and return
-            // undefined, which callers would then cast to Identity and
-            // crash downstream with an opaque error.
-            throw new Error(`Unknown serialized identity type: ${String(s.type)}`);
-    }
-}
-let warnedLegacyShape = false;
-/**
- * Accept either a modern {@link SerializedIdentity} envelope or a legacy
- * `{ privateKey }` / `{ publicKey }` shape and normalize to a
- * {@link SerializedIdentity}. Emits a one-time deprecation warning when a
- * legacy shape is seen.
- *
- * Intended for the worker-side boundary; new page builds always emit tagged
- * envelopes via {@link serializeSigningIdentity} /
- * {@link serializeReadonlyIdentity}.
- */
-export function normalizeSerializedIdentity(shape) {
-    if ("type" in shape) {
-        assertValidSerializedIdentity(shape);
-        return shape;
-    }
-    if (!warnedLegacyShape) {
-        warnedLegacyShape = true;
-        console.warn("[ts-sdk] Received legacy serialized identity shape " +
-            "(privateKey/publicKey). Upgrade the page build to the latest " +
-            "@arkade-os/sdk — this compatibility path will be removed in " +
-            "the next major.");
-    }
-    if ("privateKey" in shape && typeof shape.privateKey === "string") {
-        return { type: "single-key", privateKey: shape.privateKey };
-    }
-    if ("publicKey" in shape && typeof shape.publicKey === "string") {
-        return { type: "readonly-single-key", publicKey: shape.publicKey };
-    }
-    throw new Error("Unrecognized serialized identity shape");
-}
-/**
- * Runtime-validate that a tagged envelope carries the fields its variant
- * requires. The SDK's own serializer produces well-formed envelopes; this
- * guard exists so a malformed message (older SDK version mismatch,
- * hand-built config, etc.) fails loudly at the wire boundary rather than
- * with an opaque `"Cannot read properties of undefined"` deep inside a
- * hydrator.
- */
-function assertValidSerializedIdentity(s) {
-    const kind = s.type;
-    const bad = (field, expected) => {
-        throw new Error(`Malformed serialized identity ({ type: ${JSON.stringify(kind)} }): ` +
-            `missing or invalid "${field}" (expected ${expected})`);
-    };
-    const asStr = (key) => {
-        const v = s[key];
-        return typeof v === "string" ? v : bad(key, "string");
-    };
-    switch (kind) {
-        case "single-key":
-            asStr("privateKey");
-            return;
-        case "readonly-single-key":
-            asStr("publicKey");
-            return;
-        case "seed":
-            asStr("seed");
-            asStr("descriptor");
-            return;
-        case "mnemonic": {
-            asStr("mnemonic");
-            asStr("descriptor");
-            const passphrase = s.passphrase;
-            if (passphrase !== undefined && typeof passphrase !== "string") {
-                bad("passphrase", "string | undefined");
-            }
-            return;
-        }
-        case "readonly-descriptor":
-            asStr("descriptor");
-            return;
-        default:
-            throw new Error(`Unknown serialized identity type: ${String(kind)}`);
-    }
-}