@0xsequence/wallet-wdk 3.0.0-beta.8 → 3.0.0

package/src/env.ts

@@ -0,0 +1,58 @@
+import type { CoreEnv } from '@0xsequence/wallet-core'
+import { resolveCoreEnv } from '@0xsequence/wallet-core'
+
+export type TimersLike = {
+  setTimeout: typeof setTimeout
+  clearTimeout: typeof clearTimeout
+  setInterval: typeof setInterval
+  clearInterval: typeof clearInterval
+}
+
+export type LockManagerLike = {
+  request: (name: string, callback: (lock: Lock | null) => Promise<void> | void) => Promise<void>
+}
+
+export type NavigationLike = {
+  getPathname: () => string
+  redirect: (url: string) => void
+}
+
+export type WdkEnv = CoreEnv & {
+  timers?: TimersLike
+  locks?: LockManagerLike
+  navigation?: NavigationLike
+  urlSearchParams?: typeof URLSearchParams
+}
+
+export function resolveWdkEnv(env?: WdkEnv): WdkEnv {
+  const core = resolveCoreEnv(env)
+  const globalObj = globalThis as any
+  const windowObj = typeof window !== 'undefined' ? window : (globalObj.window ?? {})
+  const location = windowObj.location ?? globalObj.location
+
+  return {
+    ...core,
+    timers:
+      env?.timers ??
+      (typeof globalObj.setTimeout === 'function'
+        ? {
+            setTimeout: globalObj.setTimeout.bind(globalObj),
+            clearTimeout: globalObj.clearTimeout.bind(globalObj),
+            setInterval: globalObj.setInterval.bind(globalObj),
+            clearInterval: globalObj.clearInterval.bind(globalObj),
+          }
+        : undefined),
+    locks: env?.locks ?? globalObj.navigator?.locks ?? windowObj.navigator?.locks,
+    navigation:
+      env?.navigation ??
+      (location
+        ? {
+            getPathname: () => location.pathname,
+            redirect: (url: string) => {
+              location.href = url
+            },
+          }
+        : undefined),
+    urlSearchParams: env?.urlSearchParams ?? globalObj.URLSearchParams ?? windowObj.URLSearchParams,
+  }
+}

package/src/identity/signer.ts

@@ -1,17 +1,22 @@
-import { Address, Signature, Hex, Bytes, PersonalMessage } from 'ox'
-import { Signers, State } from '@0xsequence/wallet-core'
-import { IdentityInstrument, KeyType } from '@0xsequence/identity-instrument'
+import { Address, Signature, Hex, Bytes } from 'ox'
+import { Signers, State, type CryptoLike } from '@0xsequence/wallet-core'
+import { IdentityInstrument } from '@0xsequence/identity-instrument'
 import { AuthKey } from '../dbs/auth-keys.js'
 import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives'
 import * as Identity from '@0xsequence/identity-instrument'
 
-export function toIdentityAuthKey(authKey: AuthKey): Identity.AuthKey {
+export function toIdentityAuthKey(authKey: AuthKey, crypto?: CryptoLike): Identity.AuthKey {
+  const globalObj = globalThis as any
+  const resolvedCrypto = crypto ?? globalObj.window?.crypto ?? globalObj.crypto
+  if (!resolvedCrypto?.subtle) {
+    throw new Error('crypto.subtle is not available')
+  }
   return {
     address: authKey.address,
     keyType: Identity.KeyType.WebCrypto_Secp256r1,
     signer: authKey.identitySigner,
     async sign(digest: Bytes.Bytes) {
-      const authKeySignature = await window.crypto.subtle.sign(
+      const authKeySignature = await resolvedCrypto.subtle.sign(
         {
           name: 'ECDSA',
           hash: 'SHA-256',
@@ -28,6 +33,7 @@ export class IdentitySigner implements Signers.Signer {
   constructor(
     readonly identityInstrument: IdentityInstrument,
     readonly authKey: AuthKey,
+    private readonly crypto?: CryptoLike,
   ) {}
 
   get address(): Address.Address {
@@ -47,7 +53,7 @@ export class IdentitySigner implements Signers.Signer {
   }
 
   async signDigest(digest: Bytes.Bytes): Promise<SequenceSignature.SignatureOfSignerLeafHash> {
-    const sigHex = await this.identityInstrument.sign(toIdentityAuthKey(this.authKey), digest)
+    const sigHex = await this.identityInstrument.sign(toIdentityAuthKey(this.authKey, this.crypto), digest)
     const sig = Signature.fromHex(sigHex)
     return {
       type: 'hash',
@@ -55,7 +61,7 @@ export class IdentitySigner implements Signers.Signer {
     }
   }
 
-  async witness(stateWriter: State.Writer, wallet: Address.Address, extra?: Object): Promise<void> {
+  async witness(stateWriter: State.Writer, wallet: Address.Address, extra?: object): Promise<void> {
     const payload = Payload.fromMessage(
       Hex.fromString(
         JSON.stringify({

package/src/index.ts

@@ -1,2 +1,3 @@
 export * as Identity from './identity/signer.js'
 export * as Sequence from './sequence/index.js'
+export * from './env.js'

package/src/sequence/cron.ts

@@ -17,12 +17,14 @@ export class Cron {
   private readonly STORAGE_KEY = 'sequence-cron-jobs'
   private isStopping: boolean = false
   private currentCheckJobsPromise: Promise<void> = Promise.resolve()
+  private readonly env: Shared['env']
 
   /**
    * Initializes the Cron scheduler and starts the periodic job checker.
    * @param shared Shared context for modules and logging.
    */
   constructor(private readonly shared: Shared) {
+    this.env = shared.env
     this.start()
   }
 
@@ -33,7 +35,11 @@ export class Cron {
   private start() {
     if (this.isStopping) return
     this.executeCheckJobsChain()
-    this.checkInterval = setInterval(() => this.executeCheckJobsChain(), 60 * 1000)
+    const setIntervalFn = this.env.timers?.setInterval ?? (globalThis as any).setInterval
+    if (!setIntervalFn) {
+      return
+    }
+    this.checkInterval = setIntervalFn(() => this.executeCheckJobsChain(), 60 * 1000)
   }
 
   /**
@@ -58,7 +64,10 @@ export class Cron {
     this.isStopping = true
 
     if (this.checkInterval) {
-      clearInterval(this.checkInterval)
+      const clearIntervalFn = this.env.timers?.clearInterval ?? (globalThis as any).clearInterval
+      if (clearIntervalFn) {
+        clearIntervalFn(this.checkInterval)
+      }
       this.checkInterval = undefined
       this.shared.modules.logger.log('Cron: Interval cleared.')
     }
@@ -104,48 +113,22 @@ export class Cron {
     }
 
     try {
-      await navigator.locks.request('sequence-cron-jobs', async (lock: Lock | null) => {
-        if (this.isStopping) {
-          return
-        }
-        if (!lock) {
-          return
-        }
-
-        const now = Date.now()
-        const storage = await this.getStorageState()
-
-        for (const [id, job] of this.jobs) {
+      const locks = this.env.locks ?? (globalThis as any).navigator?.locks
+      if (locks?.request) {
+        await locks.request('sequence-cron-jobs', async (lock: Lock | null) => {
           if (this.isStopping) {
-            break
+            return
           }
-
-          const lastRun = storage.get(id)?.lastRun ?? job.lastRun
-          const timeSinceLastRun = now - lastRun
-
-          if (timeSinceLastRun >= job.interval) {
-            try {
-              await job.handler()
-              if (!this.isStopping) {
-                job.lastRun = now
-                storage.set(id, { lastRun: now })
-              }
-            } catch (error) {
-              if (error instanceof DOMException && error.name === 'AbortError') {
-                this.shared.modules.logger.log(`Cron: Job ${id} was aborted.`)
-              } else {
-                console.error(`Cron job ${id} failed:`, error)
-              }
-            }
+          if (!lock) {
+            return
           }
-        }
-
-        if (!this.isStopping) {
-          await this.syncWithStorage()
-        }
-      })
+          await this.runJobs()
+        })
+      } else {
+        await this.runJobs()
+      }
     } catch (error) {
-      if (error instanceof DOMException && error.name === 'AbortError') {
+      if (this.isAbortError(error)) {
         this.shared.modules.logger.log('Cron: navigator.locks.request was aborted.')
       } else {
         console.error('Cron: Error in navigator.locks.request:', error)
@@ -153,13 +136,51 @@ export class Cron {
     }
   }
 
+  private async runJobs(): Promise<void> {
+    const now = Date.now()
+    const storage = await this.getStorageState()
+
+    for (const [id, job] of this.jobs) {
+      if (this.isStopping) {
+        break
+      }
+
+      const lastRun = storage.get(id)?.lastRun ?? job.lastRun
+      const timeSinceLastRun = now - lastRun
+
+      if (timeSinceLastRun >= job.interval) {
+        try {
+          await job.handler()
+          if (!this.isStopping) {
+            job.lastRun = now
+            storage.set(id, { lastRun: now })
+          }
+        } catch (error) {
+          if (this.isAbortError(error)) {
+            this.shared.modules.logger.log(`Cron: Job ${id} was aborted.`)
+          } else {
+            console.error(`Cron job ${id} failed:`, error)
+          }
+        }
+      }
+    }
+
+    if (!this.isStopping) {
+      await this.syncWithStorage()
+    }
+  }
+
   /**
    * Loads the persisted last run times for jobs from localStorage.
    * @returns Map of job IDs to their last run times.
    */
   private async getStorageState(): Promise<Map<string, { lastRun: number }>> {
     if (this.isStopping) return new Map()
-    const state = localStorage.getItem(this.STORAGE_KEY)
+    const storage = this.env.storage
+    if (!storage) {
+      return new Map()
+    }
+    const state = storage.getItem(this.STORAGE_KEY)
     return new Map(state ? JSON.parse(state) : [])
   }
 
@@ -168,7 +189,19 @@ export class Cron {
    */
   private async syncWithStorage() {
     if (this.isStopping) return
+    const storage = this.env.storage
+    if (!storage) {
+      return
+    }
     const state = Array.from(this.jobs.entries()).map(([id, job]) => [id, { lastRun: job.lastRun }])
-    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state))
+    storage.setItem(this.STORAGE_KEY, JSON.stringify(state))
+  }
+
+  private isAbortError(error: unknown): boolean {
+    const domException = (globalThis as any).DOMException
+    if (domException && error instanceof domException) {
+      return (error as DOMException).name === 'AbortError'
+    }
+    return (error as any)?.name === 'AbortError'
   }
 }

package/src/sequence/handlers/authcode-pkce.ts

@@ -1,10 +1,11 @@
-import { Hex, Address, Bytes } from 'ox'
+import { Hex, Bytes } from 'ox'
 import { Handler } from './handler.js'
 import * as Db from '../../dbs/index.js'
 import { Signatures } from '../signatures.js'
 import * as Identity from '@0xsequence/identity-instrument'
 import { IdentitySigner } from '../../identity/signer.js'
 import { AuthCodeHandler } from './authcode.js'
+import type { WdkEnv } from '../../env.js'
 
 export class AuthCodePkceHandler extends AuthCodeHandler implements Handler {
   constructor(
@@ -16,8 +17,9 @@ export class AuthCodePkceHandler extends AuthCodeHandler implements Handler {
     signatures: Signatures,
     commitments: Db.AuthCommitments,
     authKeys: Db.AuthKeys,
+    env?: WdkEnv,
   ) {
-    super(signupKind, issuer, oauthUrl, audience, nitro, signatures, commitments, authKeys)
+    super(signupKind, issuer, oauthUrl, audience, nitro, signatures, commitments, authKeys, env)
   }
 
   public async commitAuth(target: string, isSignUp: boolean, state?: string, signer?: string) {
@@ -40,7 +42,7 @@ export class AuthCodePkceHandler extends AuthCodeHandler implements Handler {
       isSignUp,
     })
 
-    const searchParams = new URLSearchParams({
+    const searchParams = this.serializeQuery({
       code_challenge: codeChallenge,
       code_challenge_method: 'S256',
       client_id: this.audience,
@@ -51,7 +53,7 @@ export class AuthCodePkceHandler extends AuthCodeHandler implements Handler {
       state,
     })
 
-    return `${this.oauthUrl}?${searchParams.toString()}`
+    return `${this.oauthUrl}?${searchParams}`
   }
 
   public async completeAuth(

package/src/sequence/handlers/authcode.ts

@@ -6,6 +6,7 @@ import * as Identity from '@0xsequence/identity-instrument'
 import { SignerUnavailable, SignerReady, SignerActionable, BaseSignatureRequest } from '../types/signature-request.js'
 import { IdentitySigner } from '../../identity/signer.js'
 import { IdentityHandler } from './identity.js'
+import type { NavigationLike, WdkEnv } from '../../env.js'
 
 export class AuthCodeHandler extends IdentityHandler implements Handler {
   protected redirectUri: string = ''
@@ -19,8 +20,9 @@ export class AuthCodeHandler extends IdentityHandler implements Handler {
     signatures: Signatures,
     protected readonly commitments: Db.AuthCommitments,
     authKeys: Db.AuthKeys,
+    env?: WdkEnv,
   ) {
-    super(nitro, authKeys, signatures, Identity.IdentityType.OIDC)
+    super(nitro, authKeys, signatures, Identity.IdentityType.OIDC, env)
   }
 
   public get kind() {
@@ -45,7 +47,7 @@ export class AuthCodeHandler extends IdentityHandler implements Handler {
       isSignUp,
     })
 
-    const searchParams = new URLSearchParams({
+    const searchParams = this.serializeQuery({
       client_id: this.audience,
       redirect_uri: this.redirectUri,
       response_type: 'code',
@@ -53,7 +55,7 @@ export class AuthCodeHandler extends IdentityHandler implements Handler {
       ...(this.signupKind === 'apple' ? {} : { scope: 'openid profile email' }),
     })
 
-    return `${this.oauthUrl}?${searchParams.toString()}`
+    return `${this.oauthUrl}?${searchParams}`
   }
 
   public async completeAuth(
@@ -94,10 +96,29 @@ export class AuthCodeHandler extends IdentityHandler implements Handler {
       status: 'actionable',
       message: 'request-redirect',
       handle: async () => {
-        const url = await this.commitAuth(window.location.pathname, false, request.id, address)
-        window.location.href = url
+        const navigation = this.getNavigation()
+        const url = await this.commitAuth(navigation.getPathname(), false, request.id, address)
+        navigation.redirect(url)
         return true
       },
     }
   }
+
+  protected serializeQuery(params: Record<string, string>): string {
+    const searchParamsCtor = this.env.urlSearchParams ?? (globalThis as any).URLSearchParams
+    if (searchParamsCtor) {
+      return new searchParamsCtor(params).toString()
+    }
+    return Object.entries(params)
+      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+      .join('&')
+  }
+
+  private getNavigation(): NavigationLike {
+    const navigation = this.env.navigation
+    if (!navigation) {
+      throw new Error('navigation is not available')
+    }
+    return navigation
+  }
 }

package/src/sequence/handlers/devices.ts

@@ -13,7 +13,7 @@ export class DevicesHandler implements Handler {
     private readonly devices: Devices,
   ) {}
 
-  onStatusChange(cb: () => void): () => void {
+  onStatusChange(_cb: () => void): () => void {
     return () => {}
   }
 

package/src/sequence/handlers/guard.ts

@@ -35,7 +35,7 @@ export class GuardHandler implements Handler {
     this.onPromptCode = undefined
   }
 
-  onStatusChange(cb: () => void): () => void {
+  onStatusChange(_cb: () => void): () => void {
     return () => {}
   }
 
@@ -87,8 +87,9 @@ export class GuardHandler implements Handler {
       address,
       handler: this,
       status: 'ready',
-      handle: () =>
-        new Promise(async (resolve, reject) => {
+      handle: () => {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
           try {
             const signature = await guard.signEnvelope(request.envelope)
             await this.signatures.addSignature(request.id, signature)
@@ -106,7 +107,8 @@ export class GuardHandler implements Handler {
               reject(e)
             }
           }
-        }),
+        })
+      },
     }
   }
 }

package/src/sequence/handlers/identity.ts

@@ -1,9 +1,10 @@
-import { Hex, Bytes } from 'ox'
+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, toIdentityAuthKey } from '../../identity/signer.js'
+import { resolveWdkEnv, type WdkEnv } from '../../env.js'
 
 export const identityTypeToHex = (identityType?: Identity.IdentityType): Hex.Hex => {
   // Bytes4
@@ -19,12 +20,17 @@ export const identityTypeToHex = (identityType?: Identity.IdentityType): Hex.Hex
 }
 
 export class IdentityHandler {
+  protected readonly env: WdkEnv
+
   constructor(
     private readonly nitro: Identity.IdentityInstrument,
     private readonly authKeys: Db.AuthKeys,
     private readonly signatures: Signatures,
     public readonly identityType: Identity.IdentityType,
-  ) {}
+    env?: WdkEnv,
+  ) {
+    this.env = resolveWdkEnv(env)
+  }
 
   public onStatusChange(cb: () => void): () => void {
     return this.authKeys.addListener(cb)
@@ -37,7 +43,7 @@ export class IdentityHandler {
       throw new Error('no-auth-key')
     }
 
-    const res = await this.nitro.commitVerifier(toIdentityAuthKey(authKey), challenge)
+    const res = await this.nitro.commitVerifier(toIdentityAuthKey(authKey, this.env.crypto), challenge)
     return res
   }
 
@@ -47,7 +53,7 @@ export class IdentityHandler {
       throw new Error('no-auth-key')
     }
 
-    const res = await this.nitro.completeAuth(toIdentityAuthKey(authKey), challenge)
+    const res = await this.nitro.completeAuth(toIdentityAuthKey(authKey, this.env.crypto), challenge)
 
     authKey.identitySigner = res.signer.address
     authKey.expiresAt = new Date(Date.now() + 1000 * 60 * 3) // 3 minutes
@@ -55,7 +61,7 @@ export class IdentityHandler {
     await this.authKeys.delBySigner(authKey.identitySigner)
     await this.authKeys.set(authKey)
 
-    const signer = new IdentitySigner(this.nitro, authKey)
+    const signer = new IdentitySigner(this.nitro, authKey, this.env.crypto)
     return { signer, email: res.identity.email }
   }
 
@@ -72,13 +78,17 @@ export class IdentityHandler {
     if (!authKey) {
       return undefined
     }
-    return new IdentitySigner(this.nitro, authKey)
+    return new IdentitySigner(this.nitro, authKey, this.env.crypto)
   }
 
   private async getAuthKey(signer: string): Promise<Db.AuthKey | undefined> {
     let authKey = await this.authKeys.getBySigner(signer)
     if (!signer && !authKey) {
-      const keyPair = await window.crypto.subtle.generateKey(
+      const crypto = this.env.crypto ?? (globalThis as any).crypto
+      if (!crypto?.subtle) {
+        throw new Error('crypto.subtle is not available')
+      }
+      const keyPair = await crypto.subtle.generateKey(
         {
           name: 'ECDSA',
           namedCurve: 'P-256',
@@ -86,7 +96,7 @@ export class IdentityHandler {
         false,
         ['sign', 'verify'],
       )
-      const publicKey = await window.crypto.subtle.exportKey('raw', keyPair.publicKey)
+      const publicKey = await crypto.subtle.exportKey('raw', keyPair.publicKey)
       authKey = {
         address: Hex.fromBytes(new Uint8Array(publicKey)),
         identitySigner: '',

package/src/sequence/handlers/mnemonic.ts

@@ -93,8 +93,9 @@ export class MnemonicHandler implements Handler {
       handler: this,
       status: 'actionable',
       message: 'enter-mnemonic',
-      handle: () =>
-        new Promise(async (resolve, reject) => {
+      handle: () => {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
           const respond: RespondFn = async (mnemonic) => {
             const signer = MnemonicHandler.toSigner(mnemonic)
             if (!signer) {
@@ -117,7 +118,8 @@ export class MnemonicHandler implements Handler {
             resolve(true)
           }
           await onPromptMnemonic(respond)
-        }),
+        })
+      },
     }
   }
 }

package/src/sequence/handlers/otp.ts

@@ -8,6 +8,7 @@ import { SignerUnavailable, SignerReady, SignerActionable, BaseSignatureRequest
 import { Kinds } from '../types/signer.js'
 import { IdentityHandler } from './identity.js'
 import { AnswerIncorrectError, ChallengeExpiredError, TooManyAttemptsError } from '../errors.js'
+import type { WdkEnv } from '../../env.js'
 
 type RespondFn = (otp: string) => Promise<void>
 
@@ -18,8 +19,8 @@ export class OtpHandler extends IdentityHandler implements Handler {
 
   private onPromptOtp: undefined | PromptOtpHandler
 
-  constructor(nitro: Identity.IdentityInstrument, signatures: Signatures, authKeys: Db.AuthKeys) {
-    super(nitro, authKeys, signatures, Identity.IdentityType.Email)
+  constructor(nitro: Identity.IdentityInstrument, signatures: Signatures, authKeys: Db.AuthKeys, env?: WdkEnv) {
+    super(nitro, authKeys, signatures, Identity.IdentityType.Email, env)
   }
 
   public registerUI(onPromptOtp: PromptOtpHandler) {
@@ -84,7 +85,7 @@ export class OtpHandler extends IdentityHandler implements Handler {
         try {
           await this.handleAuth(challenge, onPromptOtp)
           return true
-        } catch (e) {
+        } catch {
           return false
         }
       },
@@ -95,6 +96,7 @@ export class OtpHandler extends IdentityHandler implements Handler {
     challenge: Identity.OtpChallenge,
     onPromptOtp: PromptOtpHandler,
   ): Promise<{ signer: Signers.Signer & Signers.Witnessable; email: string }> {
+    // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
       try {
         const { loginHint, challenge: codeChallenge } = await this.nitroCommitVerifier(challenge)

package/src/sequence/handlers/passkeys.ts

@@ -1,33 +1,35 @@
-import { Signers, State } from '@0xsequence/wallet-core'
+import { State } from '@0xsequence/wallet-core'
 import { Address, Hex } from 'ox'
 import { Kinds } from '../types/signer.js'
 import { Signatures } from '../signatures.js'
-import { Extensions } from '@0xsequence/wallet-primitives'
+import { Config, Extensions } from '@0xsequence/wallet-primitives'
 import { Handler } from './handler.js'
 import { SignerActionable, SignerUnavailable, BaseSignatureRequest } from '../types/index.js'
+import type { PasskeyProvider, PasskeySigner } from '../passkeys-provider.js'
 
 export class PasskeysHandler implements Handler {
   kind = Kinds.LoginPasskey
-  private readySigners = new Map<string, Signers.Passkey.Passkey>()
+  private readySigners = new Map<string, PasskeySigner>()
 
   constructor(
     private readonly signatures: Signatures,
     private readonly extensions: Pick<Extensions.Extensions, 'passkeys'>,
     private readonly stateReader: State.Reader,
+    private readonly passkeyProvider: PasskeyProvider,
   ) {}
 
-  onStatusChange(cb: () => void): () => void {
+  onStatusChange(_cb: () => void): () => void {
     return () => {}
   }
 
-  public addReadySigner(signer: Signers.Passkey.Passkey) {
+  public addReadySigner(signer: PasskeySigner) {
     // Use credentialId as key to match specific passkey instances
     this.readySigners.set(signer.credentialId, signer)
   }
 
-  private async loadPasskey(wallet: Address.Address, imageHash: Hex.Hex): Promise<Signers.Passkey.Passkey | undefined> {
+  private async loadPasskey(wallet: Address.Address, imageHash: Hex.Hex): Promise<PasskeySigner | undefined> {
     try {
-      return await Signers.Passkey.Passkey.loadFromWitness(this.stateReader, this.extensions, wallet, imageHash)
+      return await this.passkeyProvider.loadFromWitness(this.stateReader, this.extensions, wallet, imageHash)
     } catch (e) {
       console.warn('Failed to load passkey:', e)
       return undefined
@@ -55,7 +57,7 @@ export class PasskeysHandler implements Handler {
     }
 
     // First check if we have a ready signer that matches the imageHash
-    let passkey: Signers.Passkey.Passkey | undefined
+    let passkey: PasskeySigner | undefined
 
     // Look for a ready signer with matching imageHash
     for (const readySigner of this.readySigners.values()) {
@@ -91,12 +93,10 @@ export class PasskeysHandler implements Handler {
       message: 'request-interaction-with-passkey',
       imageHash: imageHash,
       handle: async () => {
-        const signature = await passkey.signSapient(
-          request.envelope.wallet,
-          request.envelope.chainId,
-          request.envelope.payload,
-          imageHash,
+        const normalized = Config.normalizeSignerSignature(
+          passkey.signSapient(request.envelope.wallet, request.envelope.chainId, request.envelope.payload, imageHash),
         )
+        const signature = await normalized.signature
         await this.signatures.addSignature(request.id, {
           address,
           imageHash,

package/src/sequence/handlers/recovery.ts

@@ -76,7 +76,7 @@ export class RecoveryHandler implements Handler {
           return true
         },
       }
-    } catch (e) {
+    } catch {
       return {
         address,
         handler: this,

package/src/sequence/index.ts

@@ -3,6 +3,8 @@ export { Network as Networks }
 
 export type { ManagerOptions, Databases, Sequence, Modules, Shared } from './manager.js'
 export { ManagerOptionsDefaults, CreateWalletOptionsDefaults, applyManagerOptionsDefaults, Manager } from './manager.js'
+export { defaultPasskeyProvider } from './passkeys-provider.js'
+export type { PasskeyProvider, PasskeySigner } from './passkeys-provider.js'
 export { Sessions } from './sessions.js'
 export { Signatures } from './signatures.js'
 export type {