@arkade-os/sdk 0.4.27 → 0.4.28

package/dist/types/identity/descriptor.d.ts

@@ -1,61 +0,0 @@
-/**
- * True iff `descriptor` is a Bitcoin mainnet descriptor (xpub-prefixed
- * BIP32 key).
- *
- * Note: testnet, signet, regtest, mutinynet, and other non-mainnet
- * networks all share the same `tpub` BIP32 version bytes — they cannot
- * be distinguished from one another at the descriptor level. Callers
- * that need a `Network` constants object for `expand()` pick
- * `networks.bitcoin` vs `networks.testnet` themselves; callers that
- * need the *actual* network the wallet is on must track that
- * out-of-band.
- */
-export declare function isMainnetDescriptor(descriptor: string): boolean;
-/**
- * Shared "does `candidate` belong to the identity backed by
- * `ourDescriptor`?" predicate.
- *
- * - HD descriptors (expanding to a `bip32` key) match by account xpub
- *   on both sides — index-agnostic, so a wildcard template and any
- *   concrete index under it all collapse to the same xpub.
- * - Bare `tr(pubkey)` candidates fall back to comparing the candidate
- *   pubkey against `ourXOnlyPubkey` (the cached pubkey on the identity
- *   side, since pulling it from `ourDescriptor` would require an index
- *   substitution the caller already performed).
- */
-export declare function descriptorIsOurs(candidate: string, ourDescriptor: string, ourXOnlyPubkey: Uint8Array): boolean;
-/**
- * Check if a string is a descriptor of the shape `tr(...)`.
- *
- * This is a shape check only — it does not validate the inner key material.
- * Use {@link expand} (via {@link extractPubKey} / {@link parseHDDescriptor})
- * for full parsing. The guard rejects empty bodies and missing/trailing
- * parentheses so callers can safely branch on descriptor vs. raw pubkey.
- */
-export declare function isDescriptor(value: string): boolean;
-/**
- * Normalize a value to descriptor format.
- * If already a descriptor, return as-is. If hex pubkey, wrap as tr(pubkey).
- * Throws when the value is empty or not a string so we never produce
- * malformed descriptors like `tr()` that downstream parsers would reject.
- */
-export declare function normalizeToDescriptor(value: string): string;
-/**
- * Extract the public key from a simple descriptor.
- * For simple descriptors (tr(pubkey)), extracts the pubkey using the library.
- * For HD descriptors, throws — use DescriptorProvider to derive the key.
- */
-export declare function extractPubKey(descriptor: string): string;
-/** Parsed HD descriptor components. */
-export interface ParsedHDDescriptor {
-    fingerprint: string;
-    basePath: string;
-    xpub: string;
-    derivationPath: string;
-}
-/**
- * Parse an HD descriptor into its components.
- * HD descriptors have the format: tr([fingerprint/path']xpub/derivation)
- * Returns null if the descriptor is not in HD format.
- */
-export declare function parseHDDescriptor(descriptor: string): ParsedHDDescriptor | null;

package/dist/types/identity/descriptorProvider.d.ts

@@ -1,42 +0,0 @@
-import { Transaction } from "../utils/transaction.js";
-/** A signing request that pairs a descriptor with a transaction. */
-export interface DescriptorSigningRequest {
-    /** Descriptor identifying which key to sign with */
-    descriptor: string;
-    /** Transaction to sign */
-    tx: Transaction;
-    /** Specific input indexes to sign (signs all if omitted) */
-    inputIndexes?: number[];
-}
-/**
- * Provider interface for descriptor-based signing.
- *
- * Implementations include:
- * - {@link StaticDescriptorProvider}: wraps a legacy {@link Identity} with a single key.
- * - {@link HDDescriptorProvider}: rotates through HD-derived descriptors.
- *
- * The provider has no read accessor for "current" — it is a pure descriptor
- * allocator. "What addresses am I currently bound to?" is a question the
- * contract repository answers, not the provider.
- *
- * Providers that want to participate in HD receive rotation can also
- * implement the wallet-side `ReceiveRotatorFactory` interface (see
- * `src/wallet/walletReceiveRotator.ts`). That extension is opt-in — the
- * core `DescriptorProvider` contract intentionally stays free of
- * wallet-specific concerns so HSM-backed and other minimal providers
- * don't have to know about the receive-rotation lifecycle.
- */
-export interface DescriptorProvider {
-    /**
-     * Allocate a new signing descriptor. For HD providers each call advances
-     * the internal index and returns a fresh descriptor; for single-key
-     * providers each call returns the same descriptor.
-     */
-    getNextSigningDescriptor(): Promise<string>;
-    /** Checks if a descriptor belongs to this provider. */
-    isOurs(descriptor: string): boolean;
-    /** Signs transactions, each with its own descriptor-derived key. */
-    signWithDescriptor(requests: DescriptorSigningRequest[]): Promise<Transaction[]>;
-    /** Signs a message using the key derived from the descriptor. */
-    signMessageWithDescriptor(descriptor: string, message: Uint8Array, type?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-}

package/dist/types/identity/hdCapableIdentity.d.ts

@@ -1,71 +0,0 @@
-import { Identity, ReadonlyIdentity } from "./index.js";
-import { DescriptorSigningRequest } from "./descriptorProvider.js";
-import { Transaction } from "../utils/transaction.js";
-/**
- * Read-side HD capability marker. Exposes the wildcard-suffixed account
- * descriptor *template* and the descriptor-membership predicate, but no
- * signing primitives — suitable for watch-only identities backed by an
- * xpub.
- *
- * Extracted from {@link HDCapableIdentity} so that
- * `ReadonlyDescriptorIdentity` can stand in for an HD wallet's read-only
- * surface (template-aware, derives pubkeys at any index) without having
- * to claim signing capability it cannot honour.
- */
-export interface ReadonlyHDCapableIdentity extends ReadonlyIdentity {
-    /**
-     * The wildcard-suffixed account descriptor template
-     * (e.g. `tr([fp/86'/0'/0']xpub/0/*)`). Consumers materialize a
-     * concrete descriptor by replacing the `*` with a derivation index.
-     */
-    readonly descriptor: string;
-    /**
-     * True iff `descriptor` derives from this identity's xpub/seed.
-     *
-     * @deprecated Prefer `DescriptorProvider.isOurs()` via
-     * `HDDescriptorProvider` for rotating HD wallets or
-     * `StaticDescriptorProvider` for legacy single-key wallets.
-     */
-    isOurs(descriptor: string): boolean;
-}
-/**
- * Capability marker for identities that can be rotated through an HD
- * derivation tree AND can sign at each rotated index.
- *
- * Deliberately does NOT extend `DescriptorProvider`: if an HD-capable
- * identity were silently usable as a concrete descriptor source, callers
- * could bypass receive rotation and unknowingly reuse a single address
- * forever. To use this identity as a wallet's descriptor source, wrap
- * it explicitly:
- *
- *  - `HDDescriptorProvider` — rotating, recommended for new wallets.
- *  - `StaticDescriptorProvider` — pinned to a single key, for legacy or
- *    explicitly-non-rotating use cases.
- */
-export interface HDCapableIdentity extends ReadonlyHDCapableIdentity, Identity {
-    /**
-     * Signs each request with the key derived from its descriptor.
-     *
-     * @deprecated Prefer `DescriptorProvider.signWithDescriptor()` via
-     * `HDDescriptorProvider` or `StaticDescriptorProvider`. Identities keep
-     * this method only as backing implementation for descriptor providers.
-     */
-    signWithDescriptor(requests: DescriptorSigningRequest[]): Promise<Transaction[]>;
-    /**
-     * Signs a message using the key derived from `descriptor`.
-     *
-     * @deprecated Prefer `DescriptorProvider.signMessageWithDescriptor()` via
-     * `HDDescriptorProvider` or `StaticDescriptorProvider`. Identities keep
-     * this method only as backing implementation for descriptor providers.
-     */
-    signMessageWithDescriptor(descriptor: string, message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-}
-/**
- * Structural type guard for {@link HDCapableIdentity}. Returns `true`
- * when the value exposes the four members the HD wallet flow relies on:
- * `descriptor`, `isOurs`, `signWithDescriptor`, and
- * `signMessageWithDescriptor`. Used by callers that need to opt into
- * the HD path (e.g. installing an `HDDescriptorProvider`) without
- * coupling to a concrete identity class.
- */
-export declare function isHDCapableIdentity(value: unknown): value is HDCapableIdentity;

package/dist/types/identity/index.d.ts

@@ -1,57 +0,0 @@
-import { Transaction } from "../utils/transaction.js";
-import { SignerSession } from "../tree/signingSession.js";
-export interface Identity extends ReadonlyIdentity {
-    /** Returns a signer session used for musig2 tree signing flows. */
-    signerSession(): SignerSession;
-    /** Sign an arbitrary message using the requested signature type. */
-    signMessage(message: Uint8Array, signatureType: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    /**
-     * Sign the provided transaction inputs.
-     *
-     * @param tx - Transaction to sign
-     * @param inputIndexes - Optional input indexes to sign. When omitted, the implementation should sign every signable input.
-     */
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-}
-export interface ReadonlyIdentity {
-    /** Returns the x-only public key used by Taproot scripts. */
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    /** Returns the compressed public key for this identity. */
-    compressedPublicKey(): Promise<Uint8Array>;
-}
-/** A single PSBT signing request within a batch. */
-export interface SignRequest {
-    tx: Transaction;
-    inputIndexes?: number[];
-}
-/**
- * Identity that supports signing multiple PSBTs in a single wallet interaction.
- * Browser wallet providers that support batch signing (e.g. Xverse, UniSat, OKX)
- * should implement this interface to reduce the number of confirmation popups
- * from N+1 to 1 during Arkade send transactions.
- *
- * Contract: implementations MUST return exactly one `Transaction` per request,
- * in the same order as the input array. The SDK validates this at runtime and
- * will throw if the lengths do not match.
- */
-export interface BatchSignableIdentity extends Identity {
-    /**
-     * Sign multiple transactions in a single wallet interaction.
-     *
-     * @param requests - Transactions and optional input indexes to sign
-     * @returns Signed transactions in the same order as the input requests
-     */
-    signMultiple(requests: SignRequest[]): Promise<Transaction[]>;
-}
-/** Type guard for identities that support batch signing. */
-export declare function isBatchSignable(identity: Identity): identity is BatchSignableIdentity;
-export * from "./singleKey.js";
-export type { NetworkOptions, DescriptorOptions, SeedIdentityOptions, MnemonicOptions, } from "./seedIdentity.js";
-export { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from "./seedIdentity.js";
-export * from "./serialize.js";
-export { isDescriptor, normalizeToDescriptor, extractPubKey, parseHDDescriptor, } from "./descriptor.js";
-export type { ParsedHDDescriptor } from "./descriptor.js";
-export type { DescriptorProvider, DescriptorSigningRequest, } from "./descriptorProvider.js";
-export type { HDCapableIdentity, ReadonlyHDCapableIdentity, } from "./hdCapableIdentity.js";
-export { isHDCapableIdentity } from "./hdCapableIdentity.js";
-export { StaticDescriptorProvider } from "./staticDescriptorProvider.js";

package/dist/types/identity/seedIdentity.d.ts

@@ -1,270 +0,0 @@
-import { Transaction } from "../utils/transaction.js";
-import { SignerSession } from "../tree/signingSession.js";
-import type { SerializedSigningIdentity, SerializedReadonlyIdentity } from "./serialize.js";
-import { DescriptorSigningRequest } from "./descriptorProvider.js";
-import { HDCapableIdentity, ReadonlyHDCapableIdentity } from "./hdCapableIdentity.js";
-/** Used for default BIP86 derivation with network selection. */
-export interface NetworkOptions {
-    /**
-     * Mainnet (coin type 0) or testnet (coin type 1).
-     *
-     * @defaultValue `true`
-     */
-    isMainnet?: boolean;
-}
-/** Used for a caller-supplied account-descriptor template. */
-export interface DescriptorOptions {
-    /**
-     * Account-descriptor *template* — must end with the BIP-32 wildcard
-     * suffix `/*)`. Stored as-is on {@link SeedIdentity.descriptor} and
-     * read by HD providers to rotate through derivation indices.
-     */
-    descriptor: string;
-}
-/** Either default BIP86 derivation (with optional network selection) or a caller-supplied template. */
-export type SeedIdentityOptions = NetworkOptions | DescriptorOptions;
-/** Used for deriving an identity from a BIP39 mnemonic. */
-export type MnemonicOptions = SeedIdentityOptions & {
-    /** Optional BIP39 passphrase for additional seed entropy. */
-    passphrase?: string;
-};
-/**
- * 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 declare class SeedIdentity implements HDCapableIdentity {
-    private readonly derivedKey;
-    /**
-     * Wildcard account-descriptor template (e.g.
-     * `tr([fp/86'/0'/0']xpub/0/*)`). The canonical thing to pass
-     * through the system; consumers materialize a concrete descriptor
-     * at a specific index themselves (see `HDDescriptorProvider` in
-     * the wallet layer for the rotating-counter use case).
-     */
-    readonly descriptor: string;
-    /**
-     * 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: Uint8Array, opts?: SeedIdentityOptions);
-    /**
-     * 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: Uint8Array, opts?: SeedIdentityOptions): SeedIdentity;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    compressedPublicKey(): Promise<Uint8Array>;
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    signerSession(): SignerSession;
-    /**
-     * 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).
-     */
-    toReadonly(): Promise<ReadonlyDescriptorIdentity>;
-    /**
-     * 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}.
-     *
-     * @deprecated Prefer `DescriptorProvider.isOurs()` via
-     * `HDDescriptorProvider` for rotating HD wallets or
-     * `StaticDescriptorProvider` for legacy single-key wallets.
-     */
-    isOurs(descriptor: string): boolean;
-    /**
-     * Signs each request with the key derived from its descriptor.
-     * Each descriptor must share this identity's seed ({@link isOurs}).
-     *
-     * @deprecated Prefer `DescriptorProvider.signWithDescriptor()` via
-     * `HDDescriptorProvider` or `StaticDescriptorProvider`. Identities keep
-     * this method only as backing implementation for descriptor providers.
-     */
-    signWithDescriptor(requests: DescriptorSigningRequest[]): Promise<Transaction[]>;
-    /**
-     * Signs a message with the key derived from `descriptor`.
-     *
-     * @deprecated Prefer `DescriptorProvider.signMessageWithDescriptor()` via
-     * `HDDescriptorProvider` or `StaticDescriptorProvider`. Identities keep
-     * this method only as backing implementation for descriptor providers.
-     */
-    signMessageWithDescriptor(descriptor: string, message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    private derivePrivateKeyForDescriptor;
-    private signTxWithKey;
-    private signMessageWithKey;
-}
-/**
- * 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 declare class MnemonicIdentity extends SeedIdentity {
-    private constructor();
-    /**
-     * 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: string, opts?: MnemonicOptions): MnemonicIdentity;
-}
-/**
- * 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 declare class ReadonlyDescriptorIdentity implements ReadonlyHDCapableIdentity {
-    /**
-     * Index-0 expansion of {@link descriptor}. Both the x-only pubkey
-     * (taproot, returned by the library as 32 bytes) and the compressed
-     * pubkey (derived through the bip32 node when needed) are read off
-     * this on demand — no separate caches.
-     */
-    private readonly indexZero;
-    /**
-     * Wildcard account-descriptor template (e.g.
-     * `tr([fp/86'/0'/0']xpub/0/*)`). HD rotation consumers materialize
-     * a concrete descriptor at a specific index themselves.
-     */
-    readonly descriptor: string;
-    private constructor();
-    /**
-     * 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: string): ReadonlyDescriptorIdentity;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    compressedPublicKey(): Promise<Uint8Array>;
-    /**
-     * 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}.
-     *
-     * @deprecated Prefer `DescriptorProvider.isOurs()` via
-     * `HDDescriptorProvider` for rotating HD wallets or
-     * `StaticDescriptorProvider` for legacy single-key wallets.
-     */
-    isOurs(descriptor: string): boolean;
-}
-/**
- * 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 declare function serializeSeedOwnedSigningIdentity(identity: SeedIdentity): SerializedSigningIdentity;
-/**
- * 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 declare function serializeSeedOwnedReadonlyIdentity(identity: SeedIdentity | ReadonlyDescriptorIdentity): SerializedReadonlyIdentity;

package/dist/types/identity/serialize.d.ts

@@ -1,96 +0,0 @@
-import type { Identity, ReadonlyIdentity } from "./index.js";
-/**
- * Tagged envelope for a signing identity transported across the
- * service-worker boundary. All variants are structured-clone safe
- * (plain strings only — no functions or prototypes).
- *
- * `descriptor` carries the wildcard *template* (e.g.
- * `tr([fp/86'/0'/0']xpub.../0/*)`), not a concrete index — the
- * receiving factories require a template, and storing it directly
- * means nothing here has to convert concrete → template on rehydrate.
- *
- * Adding a new variant is a source change in every worker build; keep
- * old variants around until all deployed workers handle them.
- */
-export type SerializedSigningIdentity = {
-    type: "single-key";
-    privateKey: string;
-} | {
-    type: "seed";
-    seed: string;
-    descriptor: string;
-} | {
-    type: "mnemonic";
-    mnemonic: string;
-    descriptor: string;
-    passphrase?: string;
-};
-/**
- * Tagged envelope for a readonly identity transported across the
- * service-worker boundary. All variants are structured-clone safe.
- * `descriptor` is the wildcard template (see
- * {@link SerializedSigningIdentity}).
- */
-export type SerializedReadonlyIdentity = {
-    type: "readonly-single-key";
-    publicKey: string;
-} | {
-    type: "readonly-descriptor";
-    descriptor: string;
-};
-export type SerializedIdentity = SerializedSigningIdentity | SerializedReadonlyIdentity;
-/** Type guard — true for signing envelopes, false for readonly envelopes. */
-export declare function isSigningSerialized(s: SerializedIdentity): s is SerializedSigningIdentity;
-/**
- * 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 declare function serializeSigningIdentity(identity: Identity): SerializedSigningIdentity;
-/**
- * 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 declare function serializeReadonlyIdentity(identity: ReadonlyIdentity): Promise<SerializedReadonlyIdentity>;
-/**
- * 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 declare function hydrateIdentity(s: SerializedIdentity): Identity | ReadonlyIdentity;
-/**
- * Legacy untagged shape emitted by page builds prior to the tagged
- * SerializedIdentity envelope. Retained so newer workers can still accept
- * older pages during a rolling upgrade. Slated for removal in the next major.
- *
- * @deprecated Use {@link SerializedIdentity}.
- */
-export type LegacySerializedIdentity = {
-    privateKey: string;
-} | {
-    publicKey: string;
-};
-/**
- * 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 declare function normalizeSerializedIdentity(shape: SerializedIdentity | LegacySerializedIdentity): SerializedIdentity;

package/dist/types/identity/singleKey.d.ts

@@ -1,62 +0,0 @@
-import { Identity, ReadonlyIdentity } from "./index.js";
-import { Transaction } from "../utils/transaction.js";
-import { SignerSession } from "../tree/signingSession.js";
-/**
- * In-memory single key implementation for Bitcoin transaction signing.
- *
- * @example
- * ```typescript
- * // Create from hex string
- * const key = SingleKey.fromHex('your_private_key_hex');
- *
- * // Create from raw bytes
- * const key = SingleKey.fromPrivateKey(privateKeyBytes);
- *
- * // Create random key
- * const randomKey = SingleKey.fromRandomBytes();
- *
- * // Sign a transaction
- * const signedTx = await key.sign(transaction);
- * ```
- */
-export declare class SingleKey implements Identity {
-    private key;
-    private constructor();
-    /** Create a signing identity from raw private key bytes. */
-    static fromPrivateKey(privateKey: Uint8Array): SingleKey;
-    /** Create a signing identity from a hex-encoded private key. */
-    static fromHex(privateKeyHex: string): SingleKey;
-    /** Create a signing identity with a freshly generated random private key. */
-    static fromRandomBytes(): SingleKey;
-    /**
-     * Export the private key as a hex string.
-     *
-     * @returns The private key as a hex string
-     */
-    toHex(): string;
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    compressedPublicKey(): Promise<Uint8Array>;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    signerSession(): SignerSession;
-    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    toReadonly(): Promise<ReadonlySingleKey>;
-}
-export declare class ReadonlySingleKey implements ReadonlyIdentity {
-    private readonly publicKey;
-    /** Create a readonly identity from a compressed public key. */
-    constructor(publicKey: Uint8Array);
-    /**
-     * Create a ReadonlySingleKey from a compressed public key.
-     *
-     * @param publicKey - 33-byte compressed public key (02/03 prefix + 32-byte x coordinate)
-     * @returns A new ReadonlySingleKey instance
-     * @example
-     * ```typescript
-     * const pubkey = new Uint8Array(33); // your compressed public key
-     * const readonlyKey = ReadonlySingleKey.fromPublicKey(pubkey);
-     * ```
-     */
-    static fromPublicKey(publicKey: Uint8Array): ReadonlySingleKey;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    compressedPublicKey(): Promise<Uint8Array>;
-}