@0xsequence/wallet-wdk 0.0.0-20250520201059

package/dist/sequence/handlers/identity.d.ts

@@ -0,0 +1,21 @@
+import { Hex } from 'ox';
+import * as Db from '../../dbs/index.js';
+import * as Identity from '@0xsequence/identity-instrument';
+import { Signatures } from '../signatures.js';
+import { BaseSignatureRequest } from '../types/signature-request.js';
+import { IdentitySigner } from '../../identity/signer.js';
+export declare const identityTypeToHex: (identityType?: Identity.IdentityType) => Hex.Hex;
+export declare class IdentityHandler {
+    private readonly nitro;
+    private readonly authKeys;
+    private readonly signatures;
+    readonly identityType: Identity.IdentityType;
+    constructor(nitro: Identity.IdentityInstrument, authKeys: Db.AuthKeys, signatures: Signatures, identityType: Identity.IdentityType);
+    onStatusChange(cb: () => void): () => void;
+    protected nitroCommitVerifier(challenge: Identity.Challenge): Promise<Identity.CommitVerifierReturn>;
+    protected nitroCompleteAuth(challenge: Identity.Challenge): Promise<IdentitySigner>;
+    protected sign(signer: IdentitySigner, request: BaseSignatureRequest): Promise<void>;
+    protected getAuthKeySigner(address: string): Promise<IdentitySigner | undefined>;
+    private getAuthKey;
+}
+//# sourceMappingURL=identity.d.ts.map

package/dist/sequence/handlers/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/identity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAS,MAAM,IAAI,CAAA;AAC/B,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,KAAK,QAAQ,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,cAAc,EAAqB,MAAM,0BAA0B,CAAA;AAE5E,eAAO,MAAM,iBAAiB,GAAI,eAAe,QAAQ,CAAC,YAAY,KAAG,GAAG,CAAC,GAa5E,CAAA;AAED,qBAAa,eAAe;IAExB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;aACX,YAAY,EAAE,QAAQ,CAAC,YAAY;gBAHlC,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EACrB,UAAU,EAAE,UAAU,EACvB,YAAY,EAAE,QAAQ,CAAC,YAAY;IAG9C,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;cAIjC,mBAAmB,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS;cAWjD,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS;cAiB/C,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,oBAAoB;cAQ1D,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;YAQxE,UAAU;CAsBzB"}

package/dist/sequence/handlers/identity.js

@@ -0,0 +1,86 @@
+import { Hex } from 'ox';
+import * as Identity from '@0xsequence/identity-instrument';
+import { IdentitySigner, toIdentityAuthKey } from '../../identity/signer.js';
+export const identityTypeToHex = (identityType) => {
+    // Bytes4
+    switch (identityType) {
+        case Identity.IdentityType.Guest:
+            return '0x00000000';
+        case Identity.IdentityType.Email:
+            return '0x00000001';
+        case Identity.IdentityType.OIDC:
+            return '0x00000002';
+        default:
+            // Unknown identity type
+            return '0xffffffff';
+    }
+};
+export class IdentityHandler {
+    nitro;
+    authKeys;
+    signatures;
+    identityType;
+    constructor(nitro, authKeys, signatures, identityType) {
+        this.nitro = nitro;
+        this.authKeys = authKeys;
+        this.signatures = signatures;
+        this.identityType = identityType;
+    }
+    onStatusChange(cb) {
+        return this.authKeys.addListener(cb);
+    }
+    async nitroCommitVerifier(challenge) {
+        await this.authKeys.delBySigner('');
+        const authKey = await this.getAuthKey('');
+        if (!authKey) {
+            throw new Error('no-auth-key');
+        }
+        const res = await this.nitro.commitVerifier(toIdentityAuthKey(authKey), challenge);
+        return res;
+    }
+    async nitroCompleteAuth(challenge) {
+        const authKey = await this.getAuthKey('');
+        if (!authKey) {
+            throw new Error('no-auth-key');
+        }
+        const res = await this.nitro.completeAuth(toIdentityAuthKey(authKey), challenge);
+        authKey.identitySigner = res.signer;
+        authKey.expiresAt = new Date(Date.now() + 1000 * 60 * 3); // 3 minutes
+        await this.authKeys.delBySigner('');
+        await this.authKeys.set(authKey);
+        const signer = new IdentitySigner(this.nitro, authKey);
+        return signer;
+    }
+    async sign(signer, request) {
+        const signature = await signer.sign(request.envelope.wallet, request.envelope.chainId, request.envelope.payload);
+        await this.signatures.addSignature(request.id, {
+            address: signer.address,
+            signature,
+        });
+    }
+    async getAuthKeySigner(address) {
+        const authKey = await this.getAuthKey(address);
+        if (!authKey) {
+            return undefined;
+        }
+        return new IdentitySigner(this.nitro, authKey);
+    }
+    async getAuthKey(signer) {
+        let authKey = await this.authKeys.getBySigner(signer);
+        if (!signer && !authKey) {
+            const keyPair = await window.crypto.subtle.generateKey({
+                name: 'ECDSA',
+                namedCurve: 'P-256',
+            }, false, ['sign', 'verify']);
+            const publicKey = await window.crypto.subtle.exportKey('raw', keyPair.publicKey);
+            authKey = {
+                address: Hex.fromBytes(new Uint8Array(publicKey)),
+                identitySigner: '',
+                expiresAt: new Date(Date.now() + 1000 * 60 * 60), // 1 hour
+                privateKey: keyPair.privateKey,
+            };
+            await this.authKeys.set(authKey);
+        }
+        return authKey;
+    }
+}

package/dist/sequence/handlers/index.d.ts

@@ -0,0 +1,7 @@
+export type { Handler } from './handler.js';
+export { DevicesHandler } from './devices.js';
+export { PasskeysHandler } from './passkeys.js';
+export { OtpHandler } from './otp.js';
+export { AuthCodePkceHandler } from './authcode-pkce.js';
+export { MnemonicHandler } from './mnemonic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sequence/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA"}

package/dist/sequence/handlers/index.js

@@ -0,0 +1,5 @@
+export { DevicesHandler } from './devices.js';
+export { PasskeysHandler } from './passkeys.js';
+export { OtpHandler } from './otp.js';
+export { AuthCodePkceHandler } from './authcode-pkce.js';
+export { MnemonicHandler } from './mnemonic.js';

package/dist/sequence/handlers/mnemonic.d.ts

@@ -0,0 +1,19 @@
+import { Signers } from '@0xsequence/wallet-core';
+import { Address, Hex } from 'ox';
+import { Handler } from './handler.js';
+import { Signatures } from '../signatures.js';
+import { SignerUnavailable, BaseSignatureRequest, SignerActionable } from '../types/index.js';
+type RespondFn = (mnemonic: string) => Promise<void>;
+export declare class MnemonicHandler implements Handler {
+    private readonly signatures;
+    kind: "login-mnemonic";
+    private onPromptMnemonic;
+    constructor(signatures: Signatures);
+    registerUI(onPromptMnemonic: (respond: RespondFn) => Promise<void>): () => void;
+    unregisterUI(): void;
+    onStatusChange(_cb: () => void): () => void;
+    static toSigner(mnemonic: string): Signers.Pk.Pk | undefined;
+    status(address: Address.Address, _imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerActionable>;
+}
+export {};
+//# sourceMappingURL=mnemonic.d.ts.map

package/dist/sequence/handlers/mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/mnemonic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACjD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAY,MAAM,IAAI,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAe,iBAAiB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAE1G,KAAK,SAAS,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAEpD,qBAAa,eAAgB,YAAW,OAAO;IAKjC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJvC,IAAI,mBAAsB;IAE1B,OAAO,CAAC,gBAAgB,CAAqD;gBAEhD,UAAU,EAAE,UAAU;IAE5C,UAAU,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC;IAOlE,YAAY;IAInB,cAAc,CAAC,GAAG,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;WAI7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,EAAE,GAAG,SAAS;IAS7D,MAAM,CACV,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;CA2CjD"}

package/dist/sequence/handlers/mnemonic.js

@@ -0,0 +1,67 @@
+import { Signers } from '@0xsequence/wallet-core';
+import { Hex, Mnemonic } from 'ox';
+import { Kinds } from '../types/signer.js';
+export class MnemonicHandler {
+    signatures;
+    kind = Kinds.LoginMnemonic;
+    onPromptMnemonic;
+    constructor(signatures) {
+        this.signatures = signatures;
+    }
+    registerUI(onPromptMnemonic) {
+        this.onPromptMnemonic = onPromptMnemonic;
+        return () => {
+            this.onPromptMnemonic = undefined;
+        };
+    }
+    unregisterUI() {
+        this.onPromptMnemonic = undefined;
+    }
+    onStatusChange(_cb) {
+        return () => { };
+    }
+    static toSigner(mnemonic) {
+        try {
+            const pk = Mnemonic.toPrivateKey(mnemonic);
+            return new Signers.Pk.Pk(Hex.from(pk));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async status(address, _imageHash, request) {
+        const onPromptMnemonic = this.onPromptMnemonic;
+        if (!onPromptMnemonic) {
+            return {
+                address,
+                handler: this,
+                reason: 'ui-not-registered',
+                status: 'unavailable',
+            };
+        }
+        return {
+            address,
+            handler: this,
+            status: 'actionable',
+            message: 'enter-mnemonic',
+            handle: () => new Promise(async (resolve, reject) => {
+                const respond = async (mnemonic) => {
+                    const signer = MnemonicHandler.toSigner(mnemonic);
+                    if (!signer) {
+                        return reject('invalid-mnemonic');
+                    }
+                    if (signer.address !== address) {
+                        return reject('wrong-mnemonic');
+                    }
+                    const signature = await signer.sign(request.envelope.wallet, request.envelope.chainId, request.envelope.payload);
+                    await this.signatures.addSignature(request.id, {
+                        address,
+                        signature,
+                    });
+                    resolve(true);
+                };
+                await onPromptMnemonic(respond);
+            }),
+        };
+    }
+}

package/dist/sequence/handlers/otp.d.ts

@@ -0,0 +1,20 @@
+import { Hex, Address } from 'ox';
+import { Signers } from '@0xsequence/wallet-core';
+import * as Identity from '@0xsequence/identity-instrument';
+import { Handler } from './handler.js';
+import * as Db from '../../dbs/index.js';
+import { Signatures } from '../signatures.js';
+import { SignerUnavailable, SignerReady, SignerActionable, BaseSignatureRequest } from '../types/signature-request.js';
+import { IdentityHandler } from './identity.js';
+type RespondFn = (otp: string) => Promise<void>;
+export declare class OtpHandler extends IdentityHandler implements Handler {
+    kind: "login-email-otp";
+    private onPromptOtp;
+    constructor(nitro: Identity.IdentityInstrument, signatures: Signatures, authKeys: Db.AuthKeys);
+    registerUI(onPromptOtp: (recipient: string, respond: RespondFn) => Promise<void>): () => void;
+    unregisterUI(): void;
+    getSigner(email: string): Promise<Signers.Signer & Signers.Witnessable>;
+    status(address: Address.Address, _imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerReady | SignerActionable>;
+}
+export {};
+//# sourceMappingURL=otp.d.ts.map

package/dist/sequence/handlers/otp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otp.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/otp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACjD,OAAO,KAAK,QAAQ,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAEtH,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE/C,qBAAa,UAAW,SAAQ,eAAgB,YAAW,OAAO;IAChE,IAAI,oBAAsB;IAE1B,OAAO,CAAC,WAAW,CAAwE;gBAE/E,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,CAAC,QAAQ;IAItF,UAAU,CAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC;IAOhF,YAAY;IAIN,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAsB9E,MAAM,CACV,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;CAgD/D"}

package/dist/sequence/handlers/otp.js

@@ -0,0 +1,83 @@
+import * as Identity from '@0xsequence/identity-instrument';
+import { Kinds } from '../types/signer.js';
+import { IdentityHandler } from './identity.js';
+export class OtpHandler extends IdentityHandler {
+    kind = Kinds.LoginEmailOtp;
+    onPromptOtp;
+    constructor(nitro, signatures, authKeys) {
+        super(nitro, authKeys, signatures, Identity.IdentityType.Email);
+    }
+    registerUI(onPromptOtp) {
+        this.onPromptOtp = onPromptOtp;
+        return () => {
+            this.onPromptOtp = undefined;
+        };
+    }
+    unregisterUI() {
+        this.onPromptOtp = undefined;
+    }
+    async getSigner(email) {
+        const onPromptOtp = this.onPromptOtp;
+        if (!onPromptOtp) {
+            throw new Error('otp-handler-ui-not-registered');
+        }
+        const challenge = Identity.OtpChallenge.fromRecipient(this.identityType, email);
+        const { loginHint, challenge: codeChallenge } = await this.nitroCommitVerifier(challenge);
+        return new Promise(async (resolve, reject) => {
+            const respond = async (otp) => {
+                try {
+                    const signer = await this.nitroCompleteAuth(challenge.withAnswer(codeChallenge, otp));
+                    resolve(signer);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            await onPromptOtp(loginHint, respond);
+        });
+    }
+    async status(address, _imageHash, request) {
+        const onPromptOtp = this.onPromptOtp;
+        if (!onPromptOtp) {
+            return {
+                address,
+                handler: this,
+                reason: 'ui-not-registered',
+                status: 'unavailable',
+            };
+        }
+        const signer = await this.getAuthKeySigner(address);
+        if (signer) {
+            return {
+                address,
+                handler: this,
+                status: 'ready',
+                handle: async () => {
+                    await this.sign(signer, request);
+                    return true;
+                },
+            };
+        }
+        return {
+            address,
+            handler: this,
+            status: 'actionable',
+            message: 'request-otp',
+            handle: () => new Promise(async (resolve, reject) => {
+                const challenge = Identity.OtpChallenge.fromSigner(this.identityType, address);
+                const { loginHint, challenge: codeChallenge } = await this.nitroCommitVerifier(challenge);
+                const respond = async (otp) => {
+                    try {
+                        await this.nitroCompleteAuth(challenge.withAnswer(codeChallenge, otp));
+                        resolve(true);
+                    }
+                    catch (e) {
+                        resolve(false);
+                        throw e;
+                    }
+                };
+                await onPromptOtp(loginHint, respond);
+            }),
+        };
+    }
+}

package/dist/sequence/handlers/passkeys.d.ts

@@ -0,0 +1,17 @@
+import { State } from '@0xsequence/wallet-core';
+import { Address, Hex } from 'ox';
+import { Signatures } from '../signatures.js';
+import { Extensions } from '@0xsequence/wallet-primitives';
+import { Handler } from './handler.js';
+import { SignerActionable, SignerUnavailable, BaseSignatureRequest } from '../types/index.js';
+export declare class PasskeysHandler implements Handler {
+    private readonly signatures;
+    private readonly extensions;
+    private readonly stateReader;
+    kind: "login-passkey";
+    constructor(signatures: Signatures, extensions: Pick<Extensions.Extensions, 'passkeys'>, stateReader: State.Reader);
+    onStatusChange(cb: () => void): () => void;
+    private loadPasskey;
+    status(address: Address.Address, imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerActionable | SignerUnavailable>;
+}
+//# sourceMappingURL=passkeys.d.ts.map

package/dist/sequence/handlers/passkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/passkeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AAEjC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAE7F,qBAAa,eAAgB,YAAW,OAAO;IAI3C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAL9B,IAAI,kBAAqB;gBAGN,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,EACnD,WAAW,EAAE,KAAK,CAAC,MAAM;IAG5C,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;YAI5B,WAAW;IASnB,MAAM,CACV,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,SAAS,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC9B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gBAAgB,GAAG,iBAAiB,CAAC;CAiDjD"}

package/dist/sequence/handlers/passkeys.js

@@ -0,0 +1,63 @@
+import { Signers } from '@0xsequence/wallet-core';
+import { Kinds } from '../types/signer.js';
+export class PasskeysHandler {
+    signatures;
+    extensions;
+    stateReader;
+    kind = Kinds.LoginPasskey;
+    constructor(signatures, extensions, stateReader) {
+        this.signatures = signatures;
+        this.extensions = extensions;
+        this.stateReader = stateReader;
+    }
+    onStatusChange(cb) {
+        return () => { };
+    }
+    async loadPasskey(wallet, imageHash) {
+        try {
+            return await Signers.Passkey.Passkey.loadFromWitness(this.stateReader, this.extensions, wallet, imageHash);
+        }
+        catch (e) {
+            console.warn('Failed to load passkey:', e);
+            return undefined;
+        }
+    }
+    async status(address, imageHash, request) {
+        const base = { address, imageHash, handler: this };
+        if (address !== this.extensions.passkeys) {
+            console.warn('PasskeySigner: status address does not match passkey module address', address, this.extensions.passkeys);
+            const status = {
+                ...base,
+                status: 'unavailable',
+                reason: 'unknown-error',
+            };
+            return status;
+        }
+        const passkey = imageHash && (await this.loadPasskey(request.envelope.wallet, imageHash));
+        if (!passkey) {
+            console.warn('PasskeySigner: status failed to load passkey', address, imageHash);
+            const status = {
+                ...base,
+                status: 'unavailable',
+                reason: 'unknown-error',
+            };
+            return status;
+        }
+        const status = {
+            ...base,
+            status: 'actionable',
+            message: 'request-interaction-with-passkey',
+            imageHash: imageHash,
+            handle: async () => {
+                const signature = await passkey.signSapient(request.envelope.wallet, request.envelope.chainId, request.envelope.payload, imageHash);
+                await this.signatures.addSignature(request.id, {
+                    address,
+                    imageHash,
+                    signature,
+                });
+                return true;
+            },
+        };
+        return status;
+    }
+}

package/dist/sequence/handlers/recovery.d.ts

@@ -0,0 +1,15 @@
+import { Address } from 'ox/Address';
+import { BaseSignatureRequest, SignerUnavailable, SignerReady, SignerActionable } from '../types/index.js';
+import { Handler } from './handler.js';
+import { Recovery } from '../recovery.js';
+import { Hex } from 'ox';
+import { Signatures } from '../signatures.js';
+export declare class RecoveryHandler implements Handler {
+    private readonly signatures;
+    readonly recovery: Recovery;
+    kind: "recovery-extension";
+    constructor(signatures: Signatures, recovery: Recovery);
+    onStatusChange(cb: () => void): () => void;
+    status(address: Address, imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerReady | SignerActionable>;
+}
+//# sourceMappingURL=recovery.d.ts.map

package/dist/sequence/handlers/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAS,MAAM,mBAAmB,CAAA;AACjH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,qBAAa,eAAgB,YAAW,OAAO;IAI3C,OAAO,CAAC,QAAQ,CAAC,UAAU;aACX,QAAQ,EAAE,QAAQ;IAJpC,IAAI,uBAAiB;gBAGF,UAAU,EAAE,UAAU,EACvB,QAAQ,EAAE,QAAQ;IAGpC,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAIpC,MAAM,CACV,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC9B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;CA+D/D"}

package/dist/sequence/handlers/recovery.js

@@ -0,0 +1,72 @@
+import { Kinds } from '../types/index.js';
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Hex } from 'ox';
+export class RecoveryHandler {
+    signatures;
+    recovery;
+    kind = Kinds.Recovery;
+    constructor(signatures, recovery) {
+        this.signatures = signatures;
+        this.recovery = recovery;
+    }
+    onStatusChange(cb) {
+        return this.recovery.onQueuedRecoveryPayloadsUpdate(undefined, cb);
+    }
+    async status(address, imageHash, request) {
+        const queued = await this.recovery.getQueuedRecoveryPayloads(request.wallet);
+        // If there is no queued payload for this request then we are unavailable
+        const requestHash = Hex.fromBytes(Payload.hash(request.envelope.wallet, request.envelope.chainId, request.envelope.payload));
+        const found = queued.find((p) => p.payloadHash === requestHash);
+        if (!found) {
+            return {
+                address: request.wallet,
+                handler: this,
+                status: 'unavailable',
+                reason: 'no-recovery-payload-queued',
+            };
+        }
+        if (!imageHash) {
+            return {
+                address: request.wallet,
+                handler: this,
+                status: 'unavailable',
+                reason: 'no-image-hash',
+            };
+        }
+        if (found.endTimestamp > Date.now() / 1000) {
+            return {
+                address: request.wallet,
+                handler: this,
+                status: 'unavailable',
+                reason: 'timelock-not-met',
+            };
+        }
+        try {
+            const signature = await this.recovery.encodeRecoverySignature(imageHash, found.signer);
+            return {
+                address: request.wallet,
+                handler: this,
+                status: 'ready',
+                handle: async () => {
+                    this.signatures.addSignature(request.id, {
+                        imageHash,
+                        signature: {
+                            address,
+                            data: Hex.fromBytes(signature),
+                            type: 'sapient_compact',
+                        },
+                    });
+                    return true;
+                },
+            };
+        }
+        catch (e) {
+            return {
+                address: request.wallet,
+                handler: this,
+                status: 'unavailable',
+                reason: 'failed-to-encode-recovery-signature',
+            };
+        }
+    }
+}

package/dist/sequence/index.d.ts

@@ -0,0 +1,12 @@
+import { Network } from '@0xsequence/wallet-primitives';
+export { Network as Networks };
+export type { ManagerOptions, Databases, Sequence, Modules, Shared } from './manager.js';
+export { ManagerOptionsDefaults, CreateWalletOptionsDefaults, applyManagerOptionsDefaults, Manager } from './manager.js';
+export { Sessions } from './sessions.js';
+export { Signatures } from './signatures.js';
+export type { StartSignUpWithRedirectArgs, CommonSignupArgs, PasskeySignupArgs, MnemonicSignupArgs, EmailOtpSignupArgs, CompleteRedirectArgs, SignupArgs, LoginToWalletArgs, LoginToMnemonicArgs, LoginToPasskeyArgs, LoginArgs, } from './wallets.js';
+export { isLoginToWalletArgs, isLoginToMnemonicArgs, isLoginToPasskeyArgs, Wallets } from './wallets.js';
+export * from './types/index.js';
+import * as Handlers from './handlers/index.js';
+export { Handlers };
+//# sourceMappingURL=index.d.ts.map

package/dist/sequence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sequence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AACvD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,CAAA;AAE9B,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACxF,OAAO,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACxH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,YAAY,EACV,2BAA2B,EAC3B,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,GACV,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAExG,cAAc,kBAAkB,CAAA;AAChC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/sequence/index.js

@@ -0,0 +1,9 @@
+import { Network } from '@0xsequence/wallet-primitives';
+export { Network as Networks };
+export { ManagerOptionsDefaults, CreateWalletOptionsDefaults, applyManagerOptionsDefaults, Manager } from './manager.js';
+export { Sessions } from './sessions.js';
+export { Signatures } from './signatures.js';
+export { isLoginToWalletArgs, isLoginToMnemonicArgs, isLoginToPasskeyArgs, Wallets } from './wallets.js';
+export * from './types/index.js';
+import * as Handlers from './handlers/index.js';
+export { Handlers };

package/dist/sequence/logger.d.ts

@@ -0,0 +1,7 @@
+import { Shared } from './manager.js';
+export declare class Logger {
+    private readonly shared;
+    constructor(shared: Shared);
+    log(...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/sequence/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/sequence/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAErC,qBAAa,MAAM;IACL,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE3C,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAKnB"}

package/dist/sequence/logger.js

@@ -0,0 +1,11 @@
+export class Logger {
+    shared;
+    constructor(shared) {
+        this.shared = shared;
+    }
+    log(...args) {
+        if (this.shared.verbose) {
+            console.log(...args);
+        }
+    }
+}