@dfx.swiss/wallet 0.0.0-stage → 0.1.1-beta.0

package/dist/providers/price.js

@@ -0,0 +1,46 @@
+import { ApiException } from '@dfx.swiss/core';
+import { ProviderUnavailableError } from './dfx-data';
+/** A price older than this is stale; a stale price must not enter a fiat amount (§9.6). */
+export const PRICE_STALE_MS = 5 * 60 * 1000;
+/**
+ * Fiat prices of public assets, always by asset id — never by symbol (D32). A missing asset is simply
+ * unpriced ("–"); a stale price is returned as stale so callers can refuse fiat entry (§9.6). Prices never
+ * feed fee caps.
+ */
+export class PricePolicy {
+    constructor(walletData, options = {}) {
+        this.walletData = walletData;
+        this.options = options;
+    }
+    async prices(assetIds, currency, now = this.options.now ?? Date.now) {
+        const clock = now();
+        const ids = [...new Set(assetIds)].slice(0, 100);
+        let remote = [];
+        try {
+            remote = await this.walletData.prices({ assetIds: ids, currency });
+        }
+        catch (error) {
+            if (error instanceof ProviderUnavailableError || error instanceof ApiException)
+                return new Map();
+            throw error;
+        }
+        const result = new Map();
+        for (const entry of remote) {
+            if (entry.isValid !== true)
+                continue;
+            if (typeof entry.price !== 'number' || !Number.isFinite(entry.price))
+                continue;
+            const timestamp = Date.parse(entry.timestamp);
+            result.set(entry.assetId, {
+                price: entry.price,
+                stale: Number.isNaN(timestamp) || clock - timestamp > PRICE_STALE_MS,
+            });
+        }
+        return result;
+    }
+    /** Convenience: price with staleness, or `undefined` when the asset has none. */
+    priceOf(prices, assetId) {
+        return prices.get(assetId);
+    }
+}
+//# sourceMappingURL=price.js.map

package/dist/providers/price.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"price.js","sourceRoot":"","sources":["../../src/providers/price.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD,2FAA2F;AAC3F,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAQ5C;;;;GAIG;AACH,MAAM,OAAO,WAAW;IACtB,YACmB,UAAyB,EACzB,UAA8B,EAAE;QADhC,eAAU,GAAV,UAAU,CAAe;QACzB,YAAO,GAAP,OAAO,CAAyB;IAChD,CAAC;IAEJ,KAAK,CAAC,MAAM,CACV,QAAkB,EAClB,QAAgB,EAChB,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG;QAElC,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC;QACpB,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACjD,IAAI,MAAM,GAAkB,EAAE,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,wBAAwB,IAAI,KAAK,YAAY,YAAY;gBAAE,OAAO,IAAI,GAAG,EAAE,CAAC;YACjG,MAAM,KAAK,CAAC;QACd,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAA6C,CAAC;QACpE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;gBAAE,SAAS;YACrC,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;gBAAE,SAAS;YAC/E,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAC9C,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE;gBACxB,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,KAAK,GAAG,SAAS,GAAG,cAAc;aACrE,CAAC,CAAC;QACL,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,iFAAiF;IACjF,OAAO,CACL,MAAsD,EACtD,OAAe;QAEf,OAAO,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;CACF"}

package/dist/providers/snapshot.d.ts

@@ -0,0 +1,28 @@
+import type { ChainInfo } from '@dfx.swiss/core';
+/**
+ * Release-pinned registry fallback per environment (§9.2): chains, asset list and blocklists as bundled at
+ * build time. Live API answers always replace it.
+ */
+export interface WalletSnapshot {
+    env: string;
+    createdAt: string;
+    chains: ChainInfo[];
+    assets: SnapshotAsset[];
+    blocklists: SnapshotBlocklists;
+}
+export interface SnapshotAsset {
+    id: number;
+    blockchain: string;
+    name: string;
+    uniqueName?: string;
+    chainId?: number;
+    decimals?: number;
+    buyable: boolean;
+    sellable: boolean;
+    isPrivate: boolean;
+}
+export interface SnapshotBlocklists {
+    phishingDomains: string[];
+    scamAddresses: string[];
+}
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/providers/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/providers/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/providers/snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot.js.map

package/dist/providers/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../src/providers/snapshot.ts"],"names":[],"mappings":""}

package/dist/session/idle-lock.d.ts

@@ -0,0 +1,31 @@
+/** When the wallet locks itself after inactivity (D5): 60 minutes by default, or when the tab hides. */
+export type IdleDelay = number | 'tab';
+export interface IdleLockOptions {
+    delay: IdleDelay;
+    onIdle(): void;
+    target?: EventTarget;
+    now?: () => number;
+}
+/**
+ * Idle auto-lock: activity touches the timer, a 30 s tick and `visibilitychange` check it (background
+ * timers are throttled). `'tab'` locks as soon as the page hides. The check never locks on a hidden page
+ * with a plain delay — only on the tick after it becomes visible again.
+ */
+export declare class IdleLock {
+    private readonly options;
+    private readonly events;
+    private readonly now;
+    private lastActivity;
+    private timer?;
+    private stopped;
+    constructor(options: IdleLockOptions);
+    touch(): void;
+    stop(): void;
+    private start;
+    private onActivity;
+    private onVisibility;
+    private check;
+    private visibilityState;
+    private lock;
+}
+//# sourceMappingURL=idle-lock.d.ts.map

package/dist/session/idle-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle-lock.d.ts","sourceRoot":"","sources":["../../src/session/idle-lock.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC;AAEvC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAKD;;;;GAIG;AACH,qBAAa,QAAQ;IAOP,OAAO,CAAC,QAAQ,CAAC,OAAO;IANpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAiC;IAC/C,OAAO,CAAC,OAAO,CAAS;gBAEK,OAAO,EAAE,eAAe;IAOrD,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI;IAQZ,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,UAAU,CAEhB;IAEF,OAAO,CAAC,YAAY,CAKlB;IAEF,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,IAAI;CAKb"}

package/dist/session/idle-lock.js

@@ -0,0 +1,73 @@
+const CHECK_INTERVAL_MS = 30000;
+const ACTIVITY_EVENTS = ['pointerdown', 'keydown', 'wheel', 'touchstart'];
+/**
+ * Idle auto-lock: activity touches the timer, a 30 s tick and `visibilitychange` check it (background
+ * timers are throttled). `'tab'` locks as soon as the page hides. The check never locks on a hidden page
+ * with a plain delay — only on the tick after it becomes visible again.
+ */
+export class IdleLock {
+    constructor(options) {
+        this.options = options;
+        this.stopped = false;
+        this.onActivity = () => {
+            this.touch();
+        };
+        this.onVisibility = () => {
+            if (this.stopped)
+                return;
+            const state = this.visibilityState();
+            if (this.options.delay === 'tab' && state === 'hidden')
+                this.lock();
+            if (state === 'visible')
+                this.check();
+        };
+        this.events = options.target ?? defaultIdleTarget();
+        this.now = options.now ?? Date.now;
+        this.lastActivity = this.now();
+        this.start();
+    }
+    touch() {
+        this.lastActivity = this.now();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        for (const type of ACTIVITY_EVENTS)
+            this.events.removeEventListener(type, this.onActivity);
+        this.events.removeEventListener('visibilitychange', this.onVisibility);
+    }
+    start() {
+        for (const type of ACTIVITY_EVENTS)
+            this.events.addEventListener(type, this.onActivity, { passive: true });
+        this.events.addEventListener('visibilitychange', this.onVisibility);
+        if (typeof this.options.delay === 'number') {
+            this.timer = setInterval(() => this.check(), CHECK_INTERVAL_MS);
+        }
+    }
+    check() {
+        if (this.stopped)
+            return;
+        if (this.visibilityState() === 'hidden')
+            return;
+        if (typeof this.options.delay === 'number' && this.now() - this.lastActivity >= this.options.delay)
+            this.lock();
+    }
+    visibilityState() {
+        return this.events.visibilityState;
+    }
+    lock() {
+        if (this.stopped)
+            return;
+        this.stop();
+        this.options.onIdle();
+    }
+}
+/** `visibilitychange` fires on `document` and does not bubble to `window`. */
+function defaultIdleTarget() {
+    if (typeof document !== 'undefined')
+        return document;
+    return globalThis;
+}
+//# sourceMappingURL=idle-lock.js.map

package/dist/session/idle-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle-lock.js","sourceRoot":"","sources":["../../src/session/idle-lock.ts"],"names":[],"mappings":"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"}

package/dist/session/passkey-auth.d.ts

@@ -0,0 +1,95 @@
+import type { DfxApiClient, PasskeyAddress, PasskeyWallet } from '@dfx.swiss/core';
+import type { WalletEnv } from '../config/environment';
+import { CredentialCache } from '../passkey/credential-cache';
+import type { PasskeyCeremonies } from '../passkey/ceremonies';
+import { WalletError } from '../util/errors';
+import { KeyRing } from '../derivation/keyring';
+/** Wallet states the flows produce (§8.2). */
+export type WalletState = 'locked' | 'unlocked' | 'seed-mismatch' | 'compromised' | 'open-elsewhere';
+/**
+ * Result of a passkey flow: the in-memory account token and the server wallet view. `keys` is set
+ * whenever the ceremony returned PRF output, including a seed mismatch, so the caller can show the
+ * derived address. `state` is `unlocked` only after the seed check passes.
+ */
+export interface AuthResult {
+    accessToken: string;
+    wallet: PasskeyWallet;
+    keys?: KeyRing;
+    state: WalletState;
+}
+/** A server refusal (403 body code), e.g. `CredentialCompromised` or `CredentialLost`. */
+export interface PasskeyRefusal {
+    statusCode: number;
+    code?: string;
+    message: string;
+}
+export declare class PasskeyRefusedError extends WalletError {
+    readonly refusal: PasskeyRefusal;
+    constructor(refusal: PasskeyRefusal);
+}
+export interface RegisterExtras {
+    mail: string;
+    language?: string;
+    usedRef?: string;
+    recommendationCode?: string;
+    specialCode?: string;
+}
+export interface PasskeyAuthDeps {
+    api: DfxApiClient;
+    ceremonies: PasskeyCeremonies;
+    env: WalletEnv;
+    cache?: CredentialCache;
+}
+/**
+ * The passkey account flows (§8): register, login, unlock, claim, link, revoke and the seed export. The
+ * account token never leaves memory; the seed is derived only from a PRF output of a ceremony of this
+ * device and only accepted after the seed check against the server value (§6.3).
+ */
+export declare class PasskeyAuth {
+    private readonly deps;
+    constructor(deps: PasskeyAuthDeps);
+    /** Registers a new passkey wallet (2-tap ceremony, seed proof for EVM and Spark, D22). */
+    register(extras: RegisterExtras): Promise<AuthResult>;
+    /** Logs in (§8.4): the assertion authenticates; the PRF output unlocks the seed. Without PRF the session
+     * stays locked (D17); a different seed is a hard mismatch, never signed around. */
+    login(): Promise<AuthResult>;
+    /** Unlocks an already authenticated session with a fresh PRF assertion (§6.2, §11.4). */
+    unlock(): Promise<{
+        keys?: KeyRing;
+        state: WalletState;
+    }>;
+    /** Claims a passkey for an existing account with a fresh (≤ 300 s) login token (§8.6). */
+    claim(freshLoginToken: string): Promise<AuthResult>;
+    /** Links another derived address of the unlocked wallet (§8.5); EVM index i or the Bitcoin login address. */
+    link(family: 'evm' | 'bitcoin', accessToken: string, keys: KeyRing, evmIndex?: number): Promise<{
+        accessToken: string;
+        address: PasskeyAddress;
+    }>;
+    /** Revokes the wallet by proving the credential one last time (D11). */
+    revoke(reason: 'Lost' | 'Compromised'): Promise<PasskeyWallet>;
+    /**
+     * The 12 words, only behind a fresh local challenge (G5); the server is never involved.
+     * One stored active passkey is pinned. Several stored passkeys need `credentialId`, so the
+     * authenticator cannot return another wallet. No stored passkey stays discoverable.
+     */
+    exportMnemonic(credentialId?: Uint8Array): Promise<string[]>;
+    /** Server records must match family, path and address of the local derivations (bitcoin 0/0, Spark, EVM 0..99). */
+    verifyServerAddresses(wallet: PasskeyWallet, keys: KeyRing): {
+        address: string;
+        family: string;
+        matches: boolean;
+    }[];
+    /** The one active passkey on this origin. Several active passkeys are not a guess. */
+    private onlyActiveCredentialId;
+    private finishAuthentication;
+    /** The registration seed proof: EVM seed check address with EIP-191 and the Spark identity with D31. */
+    private seedProof;
+    /** Server accepts at most ten ids per status call; anything past that must be a later request. */
+    private activeExcludeIds;
+    private checkRpId;
+    private confirmOrAbort;
+    private isAddressExists;
+    private isDefinitiveRejection;
+    private cacheWallet;
+}
+//# sourceMappingURL=passkey-auth.d.ts.map

package/dist/session/passkey-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkey-auth.d.ts","sourceRoot":"","sources":["../../src/session/passkey-auth.ts"],"names":[],"mappings":"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"}

package/dist/session/passkey-auth.js

@@ -0,0 +1,356 @@
+import { ApiException } from '@dfx.swiss/core';
+import { RP_IDS, SIGN_MESSAGE_PREFIX, WALLET_NETWORKS } from '../config/environment';
+import { base64UrlDecode, base64UrlEncode, equalBytes } from '../util/bytes';
+import { WalletError } from '../util/errors';
+import { KeyRing, withPrivateKey } from '../derivation/keyring';
+import { seedPublicData } from '../derivation/public-data';
+import { mnemonicFromPrfV1 } from '../derivation/v1';
+import { seedCheck } from '../derivation/seed-check';
+import { LoginAutoSigner, signEip191 } from '../signing/auto-signer';
+import { LOGIN_TEMPLATES, buildLoginMessage } from '../signing/login-messages';
+export class PasskeyRefusedError extends WalletError {
+    constructor(refusal) {
+        super('passkey-refused', refusal.message);
+        this.refusal = refusal;
+    }
+}
+function keysFromPrf(prfOutput, env) {
+    return KeyRing.fromMnemonic(mnemonicFromPrfV1(prfOutput), { bitcoinNetwork: WALLET_NETWORKS[env].bitcoin });
+}
+/**
+ * The passkey account flows (§8): register, login, unlock, claim, link, revoke and the seed export. The
+ * account token never leaves memory; the seed is derived only from a PRF output of a ceremony of this
+ * device and only accepted after the seed check against the server value (§6.3).
+ */
+export class PasskeyAuth {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Registers a new passkey wallet (2-tap ceremony, seed proof for EVM and Spark, D22). */
+    async register(extras) {
+        const challenge = await this.deps.api.passkey.registerBegin();
+        this.checkRpId(challenge.rpId);
+        const excludeIds = (await this.activeExcludeIds()).map((id) => base64UrlDecode(id));
+        const pending = await this.deps.ceremonies.createCredential({
+            challenge: base64UrlDecode(challenge.challenge),
+            excludeCredentialIds: excludeIds,
+        });
+        const created = await this.confirmOrAbort(pending);
+        const keys = keysFromPrf(created.prfOutput, this.deps.env);
+        const proof = this.seedProof(keys);
+        const finish = (challengeId, assertion) => this.deps.api.passkey.registerFinish({
+            challengeId,
+            credential: created.attestation,
+            userHandle: base64UrlEncode(created.userHandle),
+            derivationVersion: 'V1',
+            assertion,
+            ...proof,
+            ...extras,
+        });
+        let response;
+        try {
+            response = await finish(challenge.challengeId, created.assertion);
+        }
+        catch (error) {
+            if (this.isDefinitiveRejection(error)) {
+                await pending.abort();
+                throw error;
+            }
+            try {
+                // The original attestation stays. Only the new assertion is bound to the retry challenge.
+                const retry = await this.deps.api.passkey.registerBegin();
+                this.checkRpId(retry.rpId);
+                const assertion = await this.deps.ceremonies.assert({
+                    challenge: base64UrlDecode(retry.challenge),
+                    credentialId: created.credentialId,
+                    continueCeremony: true,
+                });
+                response = await finish(retry.challengeId, assertion.assertion);
+            }
+            catch (retryError) {
+                // AddressExists means the lost finish was stored. Any other 4xx was not.
+                if (this.isDefinitiveRejection(retryError) && !this.isAddressExists(retryError))
+                    await pending.abort();
+                throw retryError;
+            }
+        }
+        this.cacheWallet(response.wallet, keys, created.credentialId);
+        return { accessToken: response.accessToken, wallet: response.wallet, keys, state: 'unlocked' };
+    }
+    /** Logs in (§8.4): the assertion authenticates; the PRF output unlocks the seed. Without PRF the session
+     * stays locked (D17); a different seed is a hard mismatch, never signed around. */
+    async login() {
+        const challenge = await this.deps.api.passkey.authenticateBegin();
+        this.checkRpId(challenge.rpId);
+        const assertion = await this.deps.ceremonies.assert({ challenge: base64UrlDecode(challenge.challenge) });
+        const response = await this.finishAuthentication(challenge.challengeId, assertion.assertion);
+        if (!assertion.prfOutput) {
+            return { ...response, state: 'locked' };
+        }
+        const keys = keysFromPrf(assertion.prfOutput, this.deps.env);
+        const state = seedCheck(keys.evm(0).address, response.wallet.seedCheckAddress)
+            ? 'unlocked'
+            : 'seed-mismatch';
+        if (state === 'unlocked')
+            this.cacheWallet(response.wallet, keys, assertion.credentialId);
+        return { ...response, keys, state };
+    }
+    /** Unlocks an already authenticated session with a fresh PRF assertion (§6.2, §11.4). */
+    async unlock() {
+        const assertion = await this.deps.ceremonies.assert({});
+        if (!assertion.prfOutput)
+            return { state: 'locked' };
+        const credentialId = base64UrlEncode(assertion.credentialId);
+        const entry = this.deps.cache?.list().find((candidate) => candidate.credentialId === credentialId);
+        if (!entry || entry.state !== 'active' || !entry.publicData)
+            return { state: 'locked' };
+        const keys = keysFromPrf(assertion.prfOutput, this.deps.env);
+        if (!seedCheck(keys.evm(0).address, entry.publicData.seedCheckAddress))
+            return { keys, state: 'seed-mismatch' };
+        return { keys, state: 'unlocked' };
+    }
+    /** Claims a passkey for an existing account with a fresh (≤ 300 s) login token (§8.6). */
+    async claim(freshLoginToken) {
+        const challenge = await this.deps.api.passkey.claimBegin(freshLoginToken);
+        this.checkRpId(challenge.rpId);
+        const pending = await this.deps.ceremonies.createCredential({
+            challenge: base64UrlDecode(challenge.challenge),
+        });
+        const created = await this.confirmOrAbort(pending);
+        const keys = keysFromPrf(created.prfOutput, this.deps.env);
+        const proof = this.seedProof(keys);
+        const finish = (challengeId, assertion, signatures) => this.deps.api.passkey.claimFinish({
+            challengeId,
+            credential: created.attestation,
+            userHandle: base64UrlEncode(created.userHandle),
+            derivationVersion: 'V1',
+            assertion,
+            address: proof.address,
+            sparkAddress: proof.sparkAddress,
+            ...signatures,
+        }, freshLoginToken);
+        const originalSignatures = { signature: proof.signature, sparkSignature: proof.sparkSignature };
+        // The server already has this address, so the credential stays. A later 4xx is not a delete.
+        const claimWithNewSignature = async () => {
+            const retry = await this.deps.api.passkey.claimBegin(freshLoginToken);
+            this.checkRpId(retry.rpId);
+            const assertion = await this.deps.ceremonies.assert({
+                challenge: base64UrlDecode(retry.challenge),
+                credentialId: created.credentialId,
+                continueCeremony: true,
+            });
+            const claimText = SIGN_MESSAGE_PREFIX[this.deps.env] +
+                LOGIN_TEMPLATES.general +
+                'passkey-claim\n' +
+                retry.challenge +
+                '\n' +
+                proof.address;
+            const signature = withPrivateKey(keys, { family: 'evm', index: 0 }, (privateKey) => signEip191(claimText, privateKey));
+            return finish(retry.challengeId, assertion.assertion, {
+                signature,
+                sparkSignature: proof.sparkSignature,
+            });
+        };
+        let response;
+        try {
+            response = await finish(challenge.challengeId, created.assertion, originalSignatures);
+        }
+        catch (error) {
+            if (this.isAddressExists(error)) {
+                response = await claimWithNewSignature();
+            }
+            else if (this.isDefinitiveRejection(error)) {
+                await pending.abort();
+                throw error;
+            }
+            else {
+                try {
+                    const retry = await this.deps.api.passkey.claimBegin(freshLoginToken);
+                    this.checkRpId(retry.rpId);
+                    const assertion = await this.deps.ceremonies.assert({
+                        challenge: base64UrlDecode(retry.challenge),
+                        credentialId: created.credentialId,
+                        continueCeremony: true,
+                    });
+                    response = await finish(retry.challengeId, assertion.assertion, originalSignatures);
+                }
+                catch (retryError) {
+                    if (this.isAddressExists(retryError)) {
+                        response = await claimWithNewSignature();
+                    }
+                    else if (this.isDefinitiveRejection(retryError)) {
+                        await pending.abort();
+                        throw retryError;
+                    }
+                    else {
+                        throw retryError;
+                    }
+                }
+            }
+        }
+        this.cacheWallet(response.wallet, keys, created.credentialId);
+        return { accessToken: response.accessToken, wallet: response.wallet, keys, state: 'unlocked' };
+    }
+    /** Links another derived address of the unlocked wallet (§8.5); EVM index i or the Bitcoin login address. */
+    async link(family, accessToken, keys, evmIndex = 0) {
+        const address = family === 'evm' ? keys.evm(evmIndex).address : keys.bitcoinAddress(0, 0).address;
+        const signer = new LoginAutoSigner(keys, this.deps.env);
+        const signature = signer.sign(family, address, buildLoginMessage(this.deps.env, address));
+        const response = await this.deps.api.passkey.link({
+            address,
+            signature,
+            family: family === 'evm' ? 'Evm' : 'Bitcoin',
+            path: family === 'evm' ? keys.evm(evmIndex).path : keys.bitcoinAddress(0, 0).path,
+        }, accessToken);
+        return { accessToken: response.accessToken, address: response.address };
+    }
+    /** Revokes the wallet by proving the credential one last time (D11). */
+    async revoke(reason) {
+        const challenge = await this.deps.api.passkey.revokeBegin();
+        this.checkRpId(challenge.rpId);
+        const assertion = await this.deps.ceremonies.assert({ challenge: base64UrlDecode(challenge.challenge) });
+        const wallet = await this.deps.api.passkey.revokeFinish({
+            challengeId: challenge.challengeId,
+            credential: assertion.assertion,
+            reason,
+        });
+        this.deps.cache?.update(base64UrlEncode(assertion.credentialId), { state: 'revoked' });
+        return wallet;
+    }
+    /**
+     * The 12 words, only behind a fresh local challenge (G5); the server is never involved.
+     * One stored active passkey is pinned. Several stored passkeys need `credentialId`, so the
+     * authenticator cannot return another wallet. No stored passkey stays discoverable.
+     */
+    async exportMnemonic(credentialId) {
+        const pinned = credentialId ?? this.onlyActiveCredentialId();
+        const assertion = await this.deps.ceremonies.assert(pinned ? { credentialId: pinned } : {});
+        if (!assertion.prfOutput)
+            throw new WalletError('prf-unavailable', 'The passkey cannot derive the seed');
+        if (pinned && !equalBytes(assertion.credentialId, pinned)) {
+            throw new WalletError('credential-mismatch', 'The authenticator returned a different passkey');
+        }
+        const keys = keysFromPrf(assertion.prfOutput, this.deps.env);
+        try {
+            const id = base64UrlEncode(assertion.credentialId);
+            const expected = this.deps.cache?.list().find((entry) => entry.credentialId === id)?.publicData?.seedCheckAddress;
+            if (expected && !seedCheck(keys.evm(0).address, expected)) {
+                throw new WalletError('seed-mismatch', 'The passkey does not match the stored wallet');
+            }
+            return keys.mnemonic().split(' ');
+        }
+        finally {
+            keys.wipe();
+        }
+    }
+    /** Server records must match family, path and address of the local derivations (bitcoin 0/0, Spark, EVM 0..99). */
+    verifyServerAddresses(wallet, keys) {
+        const local = new Map();
+        const bitcoin = keys.bitcoinAddress(0, 0);
+        local.set(bitcoin.address.toLowerCase(), { family: 'Bitcoin', path: bitcoin.path });
+        const spark = keys.sparkIdentity();
+        local.set(spark.address.toLowerCase(), { family: 'Spark', path: spark.path });
+        for (let index = 0; index < 100; index++) {
+            const account = keys.evm(index);
+            local.set(account.address.toLowerCase(), { family: 'Evm', path: account.path });
+        }
+        return wallet.addresses.map((record) => {
+            const expected = local.get(record.address.toLowerCase());
+            return {
+                address: record.address,
+                family: record.family,
+                matches: expected !== undefined && expected.family === record.family && expected.path === record.path,
+            };
+        });
+    }
+    /** The one active passkey on this origin. Several active passkeys are not a guess. */
+    onlyActiveCredentialId() {
+        const active = this.deps.cache?.list().filter((entry) => entry.state === 'active') ?? [];
+        if (active.length > 1) {
+            throw new WalletError('credential-ambiguous', 'Pass the passkey to export when several are stored');
+        }
+        if (active.length === 0)
+            return undefined;
+        return base64UrlDecode(active[0].credentialId);
+    }
+    async finishAuthentication(challengeId, assertion) {
+        try {
+            return await this.deps.api.passkey.authenticateFinish({ challengeId, credential: assertion });
+        }
+        catch (error) {
+            if (error instanceof ApiException && error.statusCode === 403) {
+                throw new PasskeyRefusedError({ statusCode: 403, code: error.code ?? error.message, message: error.message });
+            }
+            throw error;
+        }
+    }
+    /** The registration seed proof: EVM seed check address with EIP-191 and the Spark identity with D31. */
+    seedProof(keys) {
+        const signer = new LoginAutoSigner(keys, this.deps.env);
+        const address = keys.evm(0).address;
+        const sparkAddress = keys.sparkIdentity().address;
+        return {
+            address,
+            signature: signer.sign('evm', address, buildLoginMessage(this.deps.env, address)),
+            sparkAddress,
+            sparkSignature: signer.sign('spark', sparkAddress, buildLoginMessage(this.deps.env, sparkAddress)),
+        };
+    }
+    /** Server accepts at most ten ids per status call; anything past that must be a later request. */
+    async activeExcludeIds() {
+        const cache = this.deps.cache;
+        if (!cache)
+            return [];
+        const ids = cache.activeIds();
+        if (ids.length === 0)
+            return [];
+        try {
+            const known = new Set();
+            for (let offset = 0; offset < ids.length; offset += 10) {
+                const statuses = await this.deps.api.passkey.credentialStatus(ids.slice(offset, offset + 10));
+                for (const status of statuses) {
+                    if (status.status !== 'Unknown')
+                        known.add(status.credentialId);
+                }
+            }
+            return ids.filter((id) => known.has(id));
+        }
+        catch {
+            return ids;
+        }
+    }
+    checkRpId(rpId) {
+        if (rpId !== RP_IDS[this.deps.env]) {
+            throw new WalletError('wrong-origin', `The server expects RP ID ${rpId}, this wallet uses ${RP_IDS[this.deps.env]}`);
+        }
+    }
+    async confirmOrAbort(pending) {
+        try {
+            return await pending.confirm();
+        }
+        catch (error) {
+            await pending.abort();
+            throw error;
+        }
+    }
+    isAddressExists(error) {
+        return (error instanceof ApiException &&
+            error.statusCode === 409 &&
+            (error.code === 'AddressExists' || error.message === 'AddressExists'));
+    }
+    isDefinitiveRejection(error) {
+        return error instanceof ApiException && error.statusCode >= 400 && error.statusCode < 500;
+    }
+    cacheWallet(wallet, keys, credentialId) {
+        this.deps.cache?.put({
+            credentialId: base64UrlEncode(credentialId),
+            rpId: RP_IDS[this.deps.env],
+            state: wallet.status === 'Active' ? 'active' : 'revoked',
+            seedCheckAddress: wallet.seedCheckAddress,
+            publicData: seedPublicData(keys),
+            backupEligible: wallet.backupEligible,
+            createdAt: Date.now(),
+        });
+    }
+}
+//# sourceMappingURL=passkey-auth.js.map