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

package/src/sequence/manager.ts

@@ -5,6 +5,7 @@ import { createAttestationVerifyingFetch } from '@0xsequence/tee-verifier'
 import { Config, Constants, Context, Extensions, Network } from '@0xsequence/wallet-primitives'
 import { Address } from 'ox'
 import * as Db from '../dbs/index.js'
+import { resolveWdkEnv, type WdkEnv } from '../env.js'
 import { Cron } from './cron.js'
 import { Devices } from './devices.js'
 import { Guards, GuardRole } from './guards.js'
@@ -31,6 +32,7 @@ import { GuardHandler, PromptCodeHandler } from './handlers/guard.js'
 import { PasskeyCredential } from '../dbs/index.js'
 import { PromptMnemonicHandler } from './handlers/mnemonic.js'
 import { PromptOtpHandler } from './handlers/otp.js'
+import { defaultPasskeyProvider, type PasskeyProvider } from './passkeys-provider.js'
 
 export type ManagerOptions = {
   verbose?: boolean
@@ -52,6 +54,9 @@ export type ManagerOptions = {
 
   dbPruningInterval?: number
 
+  env?: WdkEnv
+  passkeyProvider?: PasskeyProvider
+
   stateProvider?: State.Provider
   networks?: Network.Network[]
   relayers?: Relayer.Relayer[] | (() => Relayer.Relayer[])
@@ -70,7 +75,7 @@ export type ManagerOptions = {
 
   identity?: {
     url?: string
-    fetch?: typeof window.fetch
+    fetch?: typeof fetch
     verifyAttestation?: boolean
     expectedPcr0?: string[]
     scope?: string
@@ -95,6 +100,72 @@ export type ManagerOptions = {
   }
 }
 
+export type ResolvedIdentityOptions = {
+  url: string
+  fetch?: typeof fetch
+  verifyAttestation: boolean
+  expectedPcr0?: string[]
+  scope?: string
+  email: {
+    enabled: boolean
+  }
+  google: {
+    enabled: boolean
+    clientId: string
+  }
+  apple: {
+    enabled: boolean
+    clientId: string
+  }
+  customProviders?: {
+    kind: `custom-${string}`
+    authMethod: 'id-token' | 'authcode' | 'authcode-pkce'
+    issuer: string
+    oauthUrl: string
+    clientId: string
+  }[]
+}
+
+export type ResolvedManagerOptions = {
+  verbose: boolean
+
+  extensions: Extensions.Extensions
+  context: Context.Context
+  context4337: Context.Context
+  guest: Address.Address
+
+  encryptedPksDb: CoreSigners.Pk.Encrypted.EncryptedPksDb
+  managerDb: Db.Wallets
+  transactionsDb: Db.Transactions
+  signaturesDb: Db.Signatures
+  messagesDb: Db.Messages
+  authCommitmentsDb: Db.AuthCommitments
+  authKeysDb: Db.AuthKeys
+  recoveryDb: Db.Recovery
+  passkeyCredentialsDb: Db.PasskeyCredentials
+
+  dbPruningInterval: number
+
+  env: WdkEnv
+  passkeyProvider: PasskeyProvider
+
+  stateProvider: State.Provider
+  networks: Network.Network[]
+  relayers: Relayer.Relayer[] | (() => Relayer.Relayer[])
+  bundlers: Bundler.Bundler[]
+  guardUrl: string
+  guardAddresses: Record<GuardRole, Address.Address>
+
+  nonWitnessableSigners: Address.Address[]
+
+  defaultGuardTopology: Config.Topology
+  defaultRecoverySettings: RecoverySettings
+
+  multiInjectedProviderDiscovery: boolean
+
+  identity: ResolvedIdentityOptions
+}
+
 export const ManagerOptionsDefaults = {
   verbose: false,
 
@@ -115,7 +186,9 @@ export const ManagerOptionsDefaults = {
 
   dbPruningInterval: 1000 * 60 * 60 * 24, // 24 hours
 
-  stateProvider: new State.Sequence.Provider(),
+  passkeyProvider: defaultPasskeyProvider,
+
+  stateProvider: typeof fetch !== 'undefined' ? new State.Sequence.Provider(undefined, fetch) : undefined,
   networks: Network.ALL,
   relayers: () => {
     if (typeof window !== 'undefined') {
@@ -160,6 +233,7 @@ export const ManagerOptionsDefaults = {
   defaultRecoverySettings: {
     requiredDeltaTime: 2592000n, // 30 days (in seconds)
     minTimestamp: 0n,
+    includeTestnets: false,
   },
 
   multiInjectedProviderDiscovery: true,
@@ -186,13 +260,45 @@ export const CreateWalletOptionsDefaults = {
   useGuard: false,
 }
 
-export function applyManagerOptionsDefaults(options?: ManagerOptions) {
-  const merged = {
-    ...ManagerOptionsDefaults,
-    ...options,
-    identity: { ...ManagerOptionsDefaults.identity, ...options?.identity },
+export function applyManagerOptionsDefaults(options?: ManagerOptions): ResolvedManagerOptions {
+  const env = resolveWdkEnv(options?.env)
+
+  const identity: ResolvedIdentityOptions = {
+    ...ManagerOptionsDefaults.identity,
+    ...options?.identity,
+    email: { ...ManagerOptionsDefaults.identity.email, ...options?.identity?.email },
+    google: { ...ManagerOptionsDefaults.identity.google, ...options?.identity?.google },
+    apple: { ...ManagerOptionsDefaults.identity.apple, ...options?.identity?.apple },
+  }
+
+  if (!identity.fetch && env.fetch) {
+    identity.fetch = env.fetch
+  }
+
+  let encryptedPksDb = options?.encryptedPksDb ?? ManagerOptionsDefaults.encryptedPksDb
+  if (!options?.encryptedPksDb && options?.env) {
+    encryptedPksDb = new CoreSigners.Pk.Encrypted.EncryptedPksDb(undefined, undefined, env)
+  }
+
+  let authKeysDb = options?.authKeysDb ?? ManagerOptionsDefaults.authKeysDb
+  if (!options?.authKeysDb && options?.env) {
+    authKeysDb = new Db.AuthKeys(undefined, env)
   }
 
+  let stateProvider = options?.stateProvider ?? ManagerOptionsDefaults.stateProvider
+  if (!options?.stateProvider && options?.env?.fetch) {
+    stateProvider = new State.Sequence.Provider(undefined, options.env.fetch)
+  } else if (!stateProvider && env.fetch) {
+    stateProvider = new State.Sequence.Provider(undefined, env.fetch)
+  }
+
+  if (!stateProvider) {
+    throw new Error('stateProvider is required. Provide ManagerOptions.stateProvider or env.fetch')
+  }
+
+  const extensions = options?.extensions ?? ManagerOptionsDefaults.extensions
+  const defaultGuardTopology = options?.defaultGuardTopology ?? ManagerOptionsDefaults.defaultGuardTopology
+
   // Merge and normalize non-witnessable signers.
   // We always include the sessions extension address for the active extensions set.
   const nonWitnessable = new Set<string>()
@@ -202,12 +308,12 @@ export function applyManagerOptionsDefaults(options?: ManagerOptions) {
   for (const address of options?.nonWitnessableSigners ?? []) {
     nonWitnessable.add(address.toLowerCase())
   }
-  nonWitnessable.add(merged.extensions.sessions.toLowerCase())
+  nonWitnessable.add(extensions.sessions.toLowerCase())
 
   // Include static signer leaves from the guard topology (e.g. recovery guard signer),
   // but ignore the placeholder address that is later replaced per-role.
-  if (merged.defaultGuardTopology) {
-    const guardTopologySigners = Config.getSigners(merged.defaultGuardTopology)
+  if (defaultGuardTopology) {
+    const guardTopologySigners = Config.getSigners(defaultGuardTopology)
     for (const signer of guardTopologySigners.signers) {
       if (Address.isEqual(signer, Constants.PlaceholderAddress)) {
         continue
@@ -219,14 +325,52 @@ export function applyManagerOptionsDefaults(options?: ManagerOptions) {
     }
   }
 
-  merged.nonWitnessableSigners = Array.from(nonWitnessable) as Address.Address[]
+  return {
+    verbose: options?.verbose ?? ManagerOptionsDefaults.verbose,
 
-  return merged
+    extensions,
+    context: options?.context ?? ManagerOptionsDefaults.context,
+    context4337: options?.context4337 ?? ManagerOptionsDefaults.context4337,
+    guest: options?.guest ?? ManagerOptionsDefaults.guest,
+
+    encryptedPksDb,
+    managerDb: options?.managerDb ?? ManagerOptionsDefaults.managerDb,
+    transactionsDb: options?.transactionsDb ?? ManagerOptionsDefaults.transactionsDb,
+    signaturesDb: options?.signaturesDb ?? ManagerOptionsDefaults.signaturesDb,
+    messagesDb: options?.messagesDb ?? ManagerOptionsDefaults.messagesDb,
+    authCommitmentsDb: options?.authCommitmentsDb ?? ManagerOptionsDefaults.authCommitmentsDb,
+    recoveryDb: options?.recoveryDb ?? ManagerOptionsDefaults.recoveryDb,
+    authKeysDb,
+    passkeyCredentialsDb: options?.passkeyCredentialsDb ?? ManagerOptionsDefaults.passkeyCredentialsDb,
+
+    dbPruningInterval: options?.dbPruningInterval ?? ManagerOptionsDefaults.dbPruningInterval,
+
+    env,
+    passkeyProvider: options?.passkeyProvider ?? ManagerOptionsDefaults.passkeyProvider,
+
+    stateProvider,
+    networks: options?.networks ?? ManagerOptionsDefaults.networks,
+    relayers: options?.relayers ?? ManagerOptionsDefaults.relayers,
+    bundlers: options?.bundlers ?? ManagerOptionsDefaults.bundlers,
+    guardUrl: options?.guardUrl ?? ManagerOptionsDefaults.guardUrl,
+    guardAddresses: options?.guardAddresses ?? ManagerOptionsDefaults.guardAddresses,
+
+    nonWitnessableSigners: Array.from(nonWitnessable) as Address.Address[],
+
+    defaultGuardTopology,
+    defaultRecoverySettings: options?.defaultRecoverySettings ?? ManagerOptionsDefaults.defaultRecoverySettings,
+
+    multiInjectedProviderDiscovery:
+      options?.multiInjectedProviderDiscovery ?? ManagerOptionsDefaults.multiInjectedProviderDiscovery,
+
+    identity,
+  }
 }
 
 export type RecoverySettings = {
   requiredDeltaTime: bigint
   minTimestamp: bigint
+  includeTestnets?: boolean
 }
 
 export type Databases = {
@@ -283,6 +427,8 @@ export type Shared = {
 
   readonly sequence: Sequence
   readonly databases: Databases
+  readonly env: WdkEnv
+  readonly passkeyProvider: PasskeyProvider
 
   readonly handlers: Map<string, Handler>
 
@@ -415,7 +561,7 @@ export class Manager {
     const ops = applyManagerOptionsDefaults(options)
 
     // Build relayers list
-    let relayers: Relayer.Relayer[] = []
+    const relayers: Relayer.Relayer[] = []
 
     // Add EIP-6963 relayers if enabled
     if (ops.multiInjectedProviderDiscovery) {
@@ -469,6 +615,9 @@ export class Manager {
         pruningInterval: ops.dbPruningInterval,
       },
 
+      env: ops.env,
+      passkeyProvider: ops.passkeyProvider,
+
       modules: {} as any,
       handlers: new Map(),
     }
@@ -501,6 +650,7 @@ export class Manager {
       modules.signatures,
       shared.sequence.extensions,
       shared.sequence.stateProvider,
+      shared.passkeyProvider,
     )
     shared.handlers.set(Kinds.LoginPasskey, this.passkeysHandler)
 
@@ -523,7 +673,7 @@ export class Manager {
     const identityInstrument = new IdentityInstrument(ops.identity.url, ops.identity.scope, verifyingFetch)
 
     if (ops.identity.email?.enabled) {
-      this.otpHandler = new OtpHandler(identityInstrument, modules.signatures, shared.databases.authKeys)
+      this.otpHandler = new OtpHandler(identityInstrument, modules.signatures, shared.databases.authKeys, shared.env)
       shared.handlers.set(Kinds.LoginEmailOtp, this.otpHandler)
     }
     if (ops.identity.google?.enabled) {
@@ -538,6 +688,7 @@ export class Manager {
           modules.signatures,
           shared.databases.authCommitments,
           shared.databases.authKeys,
+          shared.env,
         ),
       )
     }
@@ -553,6 +704,7 @@ export class Manager {
           modules.signatures,
           shared.databases.authCommitments,
           shared.databases.authKeys,
+          shared.env,
         ),
       )
     }
@@ -573,6 +725,7 @@ export class Manager {
                 modules.signatures,
                 shared.databases.authCommitments,
                 shared.databases.authKeys,
+                shared.env,
               ),
             )
             break
@@ -588,6 +741,7 @@ export class Manager {
                 modules.signatures,
                 shared.databases.authCommitments,
                 shared.databases.authKeys,
+                shared.env,
               ),
             )
             break

package/src/sequence/messages.ts

@@ -242,7 +242,7 @@ export class Messages implements MessagesInterface {
       const message = await this.getByMessageOrSignatureId(messageOrSignatureId)
       await this.shared.databases.signatures.del(message.signatureId)
       await this.shared.databases.messages.del(message.id)
-    } catch (error) {
+    } catch {
       // Ignore
     }
   }

package/src/sequence/passkeys-provider.ts

@@ -0,0 +1,55 @@
+import { Signers, State } from '@0xsequence/wallet-core'
+import type { Extensions } from '@0xsequence/wallet-primitives'
+import type { Address, Hex } from 'ox'
+
+export type PasskeySigner = Signers.SapientSigner &
+  Signers.Witnessable & {
+    credentialId: string
+    publicKey: Extensions.Passkeys.PublicKey
+    imageHash: Hex.Hex
+  }
+
+export type PasskeyProvider = {
+  create: (
+    extensions: Pick<Extensions.Extensions, 'passkeys'>,
+    options?: Signers.Passkey.CreatePasskeyOptions,
+  ) => Promise<PasskeySigner>
+  find: (
+    stateReader: State.Reader,
+    extensions: Pick<Extensions.Extensions, 'passkeys'>,
+    options?: Signers.Passkey.FindPasskeyOptions,
+  ) => Promise<PasskeySigner | undefined>
+  loadFromWitness: (
+    stateReader: State.Reader,
+    extensions: Pick<Extensions.Extensions, 'passkeys'>,
+    wallet: Address.Address,
+    imageHash: Hex.Hex,
+    options?: Signers.Passkey.FindPasskeyOptions,
+  ) => Promise<PasskeySigner | undefined>
+  fromCredential: (args: {
+    credentialId: string
+    publicKey: Extensions.Passkeys.PublicKey
+    extensions: Pick<Extensions.Extensions, 'passkeys'>
+    embedMetadata?: boolean
+    metadata?: Extensions.Passkeys.PasskeyMetadata
+    webauthn?: Signers.Passkey.WebAuthnLike
+  }) => PasskeySigner
+  isSigner?: (signer: unknown) => signer is PasskeySigner
+}
+
+export const defaultPasskeyProvider: PasskeyProvider = {
+  create: (extensions, options) => Signers.Passkey.Passkey.create(extensions, options),
+  find: (stateReader, extensions, options) => Signers.Passkey.Passkey.find(stateReader, extensions, options),
+  loadFromWitness: (stateReader, extensions, wallet, imageHash, options) =>
+    Signers.Passkey.Passkey.loadFromWitness(stateReader, extensions, wallet, imageHash, options),
+  fromCredential: ({ credentialId, publicKey, extensions, embedMetadata, metadata, webauthn }) =>
+    new Signers.Passkey.Passkey({
+      credentialId,
+      publicKey,
+      extensions,
+      embedMetadata,
+      metadata,
+      webauthn,
+    }),
+  isSigner: (signer: unknown): signer is PasskeySigner => signer instanceof Signers.Passkey.Passkey,
+}

package/src/sequence/recovery.ts

@@ -1,12 +1,16 @@
 import { Envelope } from '@0xsequence/wallet-core'
 import { Config, Constants, Extensions, GenericTree, Payload } from '@0xsequence/wallet-primitives'
-import { Address, Hex, Provider, RpcTransport } from 'ox'
+import { Abi, AbiFunction, Address, Hex, Provider, RpcTransport } from 'ox'
 import { MnemonicHandler } from './handlers/mnemonic.js'
 import { Shared } from './manager.js'
 import { Actions, Module } from './types/index.js'
 import { QueuedRecoveryPayload } from './types/recovery.js'
 import { Kinds, RecoverySigner } from './types/signer.js'
 
+const AGGREGATE3 = Abi.from([
+  'function aggregate3((address target, bool allowFailure, bytes callData)[] calls) external payable returns ((bool success, bytes returnData)[])',
+])[0]!
+
 export interface RecoveryInterface {
   /**
    * Retrieves the list of configured recovery signers for a given wallet.
@@ -284,7 +288,7 @@ export class Recovery implements RecoveryInterface {
     }
 
     await this.updateRecoveryModule(modules, (leaves) => {
-      const next = leaves.filter((l) => l.signer !== address)
+      const next = leaves.filter((l) => !Address.isEqual(l.signer, address))
       if (next.length === 0) {
         return [
           {
@@ -514,9 +518,16 @@ export class Recovery implements RecoveryInterface {
   async fetchQueuedPayloads(wallet: Address.Address, chainId?: number): Promise<QueuedRecoveryPayload[]> {
     // Create providers for each network
     const providers = this.shared.sequence.networks
-      .filter((network) => (chainId ? network.chainId === chainId : true))
+      .filter((network) =>
+        chainId
+          ? network.chainId === chainId
+          : !this.shared.sequence.defaultRecoverySettings.includeTestnets
+            ? network.type !== 'testnet'
+            : true,
+      )
       .map((network) => ({
         chainId: network.chainId,
+        multicall3Address: network.contracts?.multicall3,
         provider: Provider.from(RpcTransport.fromHttp(network.rpcUrl)),
       }))
 
@@ -526,69 +537,167 @@ export class Recovery implements RecoveryInterface {
       return []
     }
 
+    const recoveryExtension = this.shared.sequence.extensions.recovery
     const payloads: QueuedRecoveryPayload[] = []
 
-    for (const signer of signers) {
-      for (const { chainId, provider } of providers) {
-        const totalPayloads = await Extensions.Recovery.totalQueuedPayloads(
-          provider,
-          this.shared.sequence.extensions.recovery,
-          wallet,
-          signer.address,
-        )
-
-        for (let i = 0n; i < totalPayloads; i++) {
-          const payloadHash = await Extensions.Recovery.queuedPayloadHashOf(
-            provider,
-            this.shared.sequence.extensions.recovery,
-            wallet,
-            signer.address,
-            i,
-          )
-
-          const timestamp = await Extensions.Recovery.timestampForQueuedPayload(
-            provider,
-            this.shared.sequence.extensions.recovery,
-            wallet,
-            signer.address,
-            payloadHash,
-          )
-
-          const payload = await this.shared.sequence.stateProvider.getPayload(payloadHash)
-
-          // If ready, we need to check if it was executed already
-          // for this, we check if the wallet nonce for the given space
-          // is greater than the nonce in the payload
-          if (timestamp < Date.now() / 1000 && payload && Payload.isCalls(payload.payload)) {
-            const nonce = await this.shared.modules.wallets.getNonce(chainId, wallet, payload.payload.space)
-            if (nonce > i) {
-              continue
+    await Promise.all(
+      providers.map(async ({ chainId, provider, multicall3Address }) => {
+        try {
+          let totalPayloadsBySigner: bigint[]
+
+          if (multicall3Address) {
+            try {
+              // Batch all totalQueuedPayloads calls for every signer into a single Multicall3 request.
+              // This reduces N signer calls per network down to 1 call per network.
+              totalPayloadsBySigner = await this.fetchTotalQueuedPayloadsBatched(
+                provider,
+                recoveryExtension,
+                wallet,
+                signers,
+                multicall3Address,
+              )
+            } catch (err) {
+              console.error(
+                `Recovery.fetchQueuedPayloads multicall3 failed for chainId ${chainId}, retrying with individual calls:`,
+                err,
+              )
+              totalPayloadsBySigner = await this.fetchTotalQueuedPayloadsFallback(
+                provider,
+                recoveryExtension,
+                wallet,
+                signers,
+              )
             }
+          } else {
+            totalPayloadsBySigner = await this.fetchTotalQueuedPayloadsFallback(
+              provider,
+              recoveryExtension,
+              wallet,
+              signers,
+            )
           }
 
-          // The id is the index + signer address + chainId + wallet address
-          const id = `${i}-${signer.address}-${chainId}-${wallet}`
-
-          // Create a new payload
-          const payloadEntry: QueuedRecoveryPayload = {
-            id,
-            index: i,
-            recoveryModule: this.shared.sequence.extensions.recovery,
-            wallet: wallet,
-            signer: signer.address,
-            chainId,
-            startTimestamp: timestamp,
-            endTimestamp: timestamp + signer.requiredDeltaTime,
-            payloadHash,
-            payload: payload?.payload,
+          for (let s = 0; s < signers.length; s++) {
+            const signer = signers[s]!
+            const totalPayloads = totalPayloadsBySigner[s]!
+            if (totalPayloads === 0n) continue
+
+            // Only make individual calls for the rare case where payloads actually exist
+            for (let i = 0n; i < totalPayloads; i++) {
+              const payloadHash = await Extensions.Recovery.queuedPayloadHashOf(
+                provider,
+                recoveryExtension,
+                wallet,
+                signer.address,
+                i,
+              )
+
+              const timestamp = await Extensions.Recovery.timestampForQueuedPayload(
+                provider,
+                recoveryExtension,
+                wallet,
+                signer.address,
+                payloadHash,
+              )
+
+              const payload = await this.shared.sequence.stateProvider.getPayload(payloadHash)
+
+              // If ready, we need to check if it was executed already
+              // for this, we check if the wallet nonce for the given space
+              // is greater than the nonce in the payload
+              if (timestamp < Date.now() / 1000 && payload && Payload.isCalls(payload.payload)) {
+                const nonce = await this.shared.modules.wallets.getNonce(chainId, wallet, payload.payload.space)
+                if (nonce > i) {
+                  continue
+                }
+              }
+
+              // The id is the index + signer address + chainId + wallet address
+              const id = `${i}-${signer.address}-${chainId}-${wallet}`
+
+              const payloadEntry: QueuedRecoveryPayload = {
+                id,
+                index: i,
+                recoveryModule: recoveryExtension,
+                wallet: wallet,
+                signer: signer.address,
+                chainId,
+                startTimestamp: timestamp,
+                endTimestamp: timestamp + signer.requiredDeltaTime,
+                payloadHash,
+                payload: payload?.payload,
+              }
+
+              payloads.push(payloadEntry)
+            }
           }
-
-          payloads.push(payloadEntry)
+        } catch (err) {
+          console.error(`Recovery.fetchQueuedPayloads error for chainId ${chainId}:`, err)
         }
+      }),
+    )
+
+    return payloads
+  }
+
+  private async fetchTotalQueuedPayloadsBatched(
+    provider: Provider.Provider,
+    recoveryExtension: Address.Address,
+    wallet: Address.Address,
+    signers: RecoverySigner[],
+    multicall3Address: Address.Address,
+  ): Promise<bigint[]> {
+    const calls = signers.map((signer) => ({
+      target: recoveryExtension,
+      allowFailure: true,
+      callData: AbiFunction.encodeData(Extensions.Recovery.TOTAL_QUEUED_PAYLOADS, [wallet, signer.address]),
+    }))
+
+    const response = await provider.request({
+      method: 'eth_call',
+      params: [
+        {
+          to: multicall3Address,
+          data: AbiFunction.encodeData(AGGREGATE3, [calls]),
+        },
+        'latest',
+      ],
+    })
+
+    const results = AbiFunction.decodeResult(AGGREGATE3, response) as readonly {
+      success: boolean
+      returnData: Hex.Hex
+    }[]
+
+    return results.map((result) => {
+      if (!result.success || result.returnData === '0x') {
+        return 0n
       }
+      return Hex.toBigInt(result.returnData)
+    })
+  }
+
+  private fetchTotalQueuedPayloadsFallback = async (
+    provider: Provider.Provider,
+    recoveryExtension: Address.Address,
+    wallet: Address.Address,
+    signers: RecoverySigner[],
+  ): Promise<bigint[]> => {
+    const result: bigint[] = signers.map(() => 0n)
+
+    // Fallback to individual calls if the multicall3 call fails
+    for (let s = 0; s < signers.length; s++) {
+      const signer = signers[s]!
+      const totalPayloads = await Extensions.Recovery.totalQueuedPayloads(
+        provider,
+        recoveryExtension,
+        wallet,
+        signer.address,
+      )
+      result[s] = totalPayloads
     }
 
-    return payloads
+    return result
   }
 
   async encodeRecoverySignature(imageHash: Hex.Hex, signer: Address.Address) {

package/src/sequence/signers.ts

@@ -81,7 +81,9 @@ export class Signers {
       if (isWitnessExtraSignerKind(message)) {
         return toKnownKind(message.signerKind)
       }
-    } catch {}
+    } catch {
+      // ignore
+    }
 
     return undefined
   }

package/src/sequence/transactions.ts

@@ -347,7 +347,11 @@ export class Transactions implements TransactionsInterface {
               return []
             }
 
-            const feeOptions = await relayer.feeOptions(tx.wallet, tx.envelope.chainId, tx.envelope.payload.calls)
+            // Determine the to address for the built transaction
+            const walletStatus = await wallet.getStatus(provider)
+            const to = walletStatus.isDeployed ? wallet.address : wallet.guest
+
+            const feeOptions = await relayer.feeOptions(tx.wallet, tx.envelope.chainId, to, tx.envelope.payload.calls)
 
             if (feeOptions.options.length === 0) {
               const { name, icon } = relayer instanceof Relayer.EIP6963.EIP6963Relayer ? relayer.info : {}
@@ -492,7 +496,7 @@ export class Transactions implements TransactionsInterface {
     let tx: Transaction | undefined
     try {
       tx = await this.get(transactionOrSignatureId)
-    } catch (e) {
+    } catch {
       // If not found, it might be a signature ID
       const signature = await this.shared.modules.signatures.get(transactionOrSignatureId)
       if (!signature) {