@0xsequence/wallet-wdk 3.0.0-beta.17 → 3.0.0-beta.19

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.
@@ -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,73 +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) {
+    await Promise.all(
+      providers.map(async ({ chainId, provider, multicall3Address }) => {
         try {
-          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(
+          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,
-              this.shared.sequence.extensions.recovery,
+              recoveryExtension,
               wallet,
-              signer.address,
-              payloadHash,
+              signers,
             )
+          }
 
-            const payload = await this.shared.sequence.stateProvider.getPayload(payloadHash)
+          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
+                }
+              }
 
-            // 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,
               }
-            }
 
-            // 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,
+              payloads.push(payloadEntry)
             }
-
-            payloads.push(payloadEntry)
           }
         } catch (err) {
-          console.error('Recovery.fetchQueuedPayloads error', 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

@@ -496,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) {

package/src/sequence/wallets.ts

@@ -1,17 +1,16 @@
 import { Wallet as CoreWallet, Envelope, Signers, State } from '@0xsequence/wallet-core'
-import { Config, Constants, GenericTree, Payload, SessionConfig } from '@0xsequence/wallet-primitives'
+import { Config, Constants, Payload } from '@0xsequence/wallet-primitives'
 import { Address, Hex, Provider, RpcTransport } from 'ox'
 import { AuthCommitment } from '../dbs/auth-commitments.js'
 import { AuthCodeHandler } from './handlers/authcode.js'
 import { MnemonicHandler } from './handlers/mnemonic.js'
 import { OtpHandler } from './handlers/otp.js'
-import { ManagerOptionsDefaults, Shared } from './manager.js'
+import { Shared } from './manager.js'
 import { Device } from './types/device.js'
 import { Action, Module } from './types/index.js'
 import { Kinds, SignerWithKind, WitnessExtraSignerKind } from './types/signer.js'
 import { Wallet, WalletSelectionUiHandler } from './types/wallet.js'
 import { PasskeysHandler } from './handlers/passkeys.js'
-import { GuardRole } from './guards.js'
 import type { PasskeySigner } from './passkeys-provider.js'
 
 export type StartSignUpWithRedirectArgs = {
@@ -418,17 +417,17 @@ function buildCappedTree(members: { address: Address.Address; imageHash?: Hex.He
   } as Config.NestedLeaf
 }
 
-function buildCappedTreeFromTopology(weight: bigint, topology: Config.Topology): Config.Topology {
-  // We may optimize this for some topology types
-  // but it is not worth it, because the topology
-  // that we will use for prod won't be optimizable
-  return {
-    type: 'nested',
-    weight: weight,
-    threshold: weight,
-    tree: topology,
-  }
-}
+// function buildCappedTreeFromTopology(weight: bigint, topology: Config.Topology): Config.Topology {
+//   // We may optimize this for some topology types
+//   // but it is not worth it, because the topology
+//   // that we will use for prod won't be optimizable
+//   return {
+//     type: 'nested',
+//     weight: weight,
+//     threshold: weight,
+//     tree: topology,
+//   }
+// }
 
 function toConfig(
   checkpoint: bigint,
@@ -626,7 +625,7 @@ export class Wallets implements WalletsInterface {
     loginEmail?: string
   }> {
     switch (args.kind) {
-      case 'passkey':
+      case 'passkey': {
         const passkeySigner = await this.shared.passkeyProvider.create(this.shared.sequence.extensions, {
           stateProvider: this.shared.sequence.stateProvider,
           credentialName: args.name,
@@ -639,8 +638,9 @@ export class Wallets implements WalletsInterface {
             signerKind: Kinds.LoginPasskey,
           },
         }
+      }
 
-      case 'mnemonic':
+      case 'mnemonic': {
         const mnemonicSigner = MnemonicHandler.toSigner(args.mnemonic)
         if (!mnemonicSigner) {
           throw new Error('invalid-mnemonic')
@@ -654,6 +654,7 @@ export class Wallets implements WalletsInterface {
             signerKind: Kinds.LoginMnemonic,
           },
         }
+      }
 
       case 'email-otp': {
         const handler = this.shared.handlers.get(Kinds.LoginEmailOtp) as OtpHandler
@@ -835,7 +836,7 @@ export class Wallets implements WalletsInterface {
     const sessionsGuardTopology = args.noGuard ? undefined : this.shared.modules.guards.topology('sessions')
 
     // Add modules
-    let modules: Module[] = []
+    const modules: Module[] = []
 
     if (!args.noSessionManager) {
       const identitySigners = [device.address]
@@ -1044,8 +1045,6 @@ export class Wallets implements WalletsInterface {
         })
 
         return requestId
-      } catch (error) {
-        throw error
       } finally {
         this.pendingMnemonicOrPasskeyLogin = undefined
       }
@@ -1235,7 +1234,7 @@ export class Wallets implements WalletsInterface {
     return requestId
   }
 
-  async completeLogout(requestId: string, options?: { skipValidateSave?: boolean }) {
+  async completeLogout(requestId: string, _options?: { skipValidateSave?: boolean }) {
     const request = await this.shared.modules.signatures.get(requestId)
     const walletEntry = await this.shared.databases.manager.get(request.wallet)
     if (!walletEntry) {

package/test/authcode-pkce.test.ts

@@ -1,5 +1,4 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { Address, Hex, Bytes } from 'ox'
 import * as Identity from '@0xsequence/identity-instrument'
 import { AuthCodePkceHandler } from '../src/sequence/handlers/authcode-pkce.js'
 import { Signatures } from '../src/sequence/signatures.js'
@@ -68,7 +67,7 @@ describe('AuthCodePkceHandler', () => {
     handler.setRedirectUri('https://example.com/auth/callback')
 
     // Mock inherited methods
-    vi.spyOn(handler as any, 'nitroCommitVerifier').mockImplementation(async (challenge) => {
+    vi.spyOn(handler as any, 'nitroCommitVerifier').mockImplementation(async () => {
       return {
         verifier: 'mock-verifier-code',
         loginHint: 'user@example.com',
@@ -76,7 +75,7 @@ describe('AuthCodePkceHandler', () => {
       }
     })
 
-    vi.spyOn(handler as any, 'nitroCompleteAuth').mockImplementation(async (challenge) => {
+    vi.spyOn(handler as any, 'nitroCompleteAuth').mockImplementation(async () => {
       return {
         signer: mockIdentitySigner,
         email: 'user@example.com',

package/test/authcode.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { Address, Hex, Bytes } from 'ox'
+import { Address, Hex } from 'ox'
 import { Network, Payload } from '@0xsequence/wallet-primitives'
 import { IdentityInstrument, IdentityType, KeyType, AuthCodeChallenge } from '@0xsequence/identity-instrument'
 import { AuthCodeHandler } from '../src/sequence/handlers/authcode.js'
@@ -45,8 +45,8 @@ class MockURLSearchParams {
   }
 }
 
-// @ts-ignore - Override global URLSearchParams for testing
-global.URLSearchParams = MockURLSearchParams as any
+// Override global URLSearchParams for testing
+globalThis.URLSearchParams = MockURLSearchParams as any
 
 // Mock dependencies with proper vi.fn() types
 const mockCommitVerifier = vi.fn()
@@ -285,8 +285,7 @@ describe('AuthCodeHandler', () => {
     })
 
     it('Should generate random state when not provided', async () => {
-      const result = await authCodeHandler.commitAuth('/target', false)
-
+      await authCodeHandler.commitAuth('/target', false)
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
       expect(commitmentCall.id).toBeDefined()
       expect(typeof commitmentCall.id).toBe('string')
@@ -316,8 +315,7 @@ describe('AuthCodeHandler', () => {
     })
 
     it('Should create commitment without signer', async () => {
-      const result = await authCodeHandler.commitAuth('/target', true)
-
+      await authCodeHandler.commitAuth('/target', true)
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
       expect(commitmentCall.signer).toBeUndefined()
       expect(commitmentCall.isSignUp).toBe(true)
@@ -329,7 +327,7 @@ describe('AuthCodeHandler', () => {
   describe('completeAuth()', () => {
     it('Should complete auth flow with code and return signer', async () => {
       const authCode = 'test-auth-code-123'
-      const mockSigner = {} as IdentitySigner
+      // const mockSigner = {} as IdentitySigner
       const mockEmail = 'test@example.com'
 
       mockCommitVerifier.mockResolvedValueOnce(undefined)

package/test/constants.ts

@@ -7,6 +7,7 @@ import { Relayer } from '@0xsequence/relayer'
 import * as Db from '../src/dbs/index.js'
 import { Network } from '@0xsequence/wallet-primitives'
 
+// eslint-disable-next-line turbo/no-undeclared-env-vars
 const envFile = process.env.CI ? '.env.test' : '.env.test.local'
 dotenvConfig({ path: envFile })
 
@@ -14,6 +15,7 @@ export const EMITTER_ADDRESS: Address.Address = '0xb7bE532959236170064cf099e1a33
 export const EMITTER_ABI = Abi.from(['function explicitEmit()', 'function implicitEmit()'])
 
 // Environment variables
+// eslint-disable-next-line turbo/no-undeclared-env-vars
 export const LOCAL_RPC_URL = process.env.LOCAL_RPC_URL || 'http://localhost:8545'
 
 let testIdCounter = 0
@@ -81,8 +83,8 @@ export function newRemoteManager(
     ? `_${remoteManagerOptions.tag}_testrun_${testIdCounter}`
     : `_testrun_${testIdCounter}`
 
-  let relayers: Relayer.Relayer[] = []
-  let bundlers: Bundler.Bundler[] = []
+  const relayers: Relayer.Relayer[] = []
+  const bundlers: Bundler.Bundler[] = []
 
   if (remoteManagerOptions.network.relayerPk) {
     const provider = Provider.from(RpcTransport.fromHttp(remoteManagerOptions.network.rpcUrl))

package/test/guard.test.ts

@@ -5,7 +5,7 @@ import { Address, Bytes, Hex, TypedData } from 'ox'
 import { Config, Constants, Network, Payload } from '@0xsequence/wallet-primitives'
 import { Kinds } from '../src/sequence/types/signer.js'
 import { newManager } from './constants.js'
-import { GuardRole, Guards } from '../src/sequence/guards.js'
+import { Guards } from '../src/sequence/guards.js'
 
 // Mock fetch globally for guard API calls
 const mockFetch = vi.fn()
@@ -16,8 +16,8 @@ describe('GuardHandler', () => {
   let guards: Guards
   let testWallet: Address.Address
   let testPayload: Payload.Payload
-  let testMessageDigest: Bytes.Bytes
-  let testMessage: Hex.Hex
+  let _testMessageDigest: Bytes.Bytes
+  let _testMessage: Hex.Hex
 
   beforeEach(async () => {
     vi.clearAllMocks()
@@ -28,8 +28,8 @@ describe('GuardHandler', () => {
 
     testWallet = '0x1234567890123456789012345678901234567890' as Address.Address
     testPayload = Payload.fromMessage(Hex.fromString('Test message'))
-    testMessage = TypedData.encode(Payload.toTyped(testWallet, Network.ChainId.ARBITRUM, testPayload))
-    testMessageDigest = Payload.hash(testWallet, Network.ChainId.ARBITRUM, testPayload)
+    _testMessage = TypedData.encode(Payload.toTyped(testWallet, Network.ChainId.ARBITRUM, testPayload))
+    _testMessageDigest = Payload.hash(testWallet, Network.ChainId.ARBITRUM, testPayload)
   })
 
   afterEach(async () => {

package/test/identity-signer.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest'
-import { Address, Bytes, Hex } from 'ox'
+import { Address, Hex } from 'ox'
 import { Network, Payload } from '@0xsequence/wallet-primitives'
 import { IdentityInstrument, KeyType } from '@0xsequence/identity-instrument'
 import { State } from '@0xsequence/wallet-core'

package/test/otp.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest'
 import { Address, Hex } from 'ox'
 import { Network, Payload } from '@0xsequence/wallet-primitives'
-import { IdentityInstrument, IdentityType, KeyType, OtpChallenge } from '@0xsequence/identity-instrument'
+import { IdentityInstrument, IdentityType, KeyType } from '@0xsequence/identity-instrument'
 import { OtpHandler, PromptOtpHandler } from '../src/sequence/handlers/otp.js'
 import { Signatures } from '../src/sequence/signatures.js'
 import * as Db from '../src/dbs/index.js'

package/test/passkeys.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { Address, Hex } from 'ox'
 import { Network, Payload } from '@0xsequence/wallet-primitives'
-import { Signers, State } from '@0xsequence/wallet-core'
+import { State } from '@0xsequence/wallet-core'
 import { Extensions } from '@0xsequence/wallet-primitives'
 import { PasskeysHandler } from '../src/sequence/handlers/passkeys.js'
 import { Signatures } from '../src/sequence/signatures.js'

package/test/recovery.test.ts

@@ -174,7 +174,7 @@ describe('Recovery', () => {
     const recoverySigner = request4.signers.find((s) => s.handler?.kind === 'recovery-extension')
     expect(recoverySigner).toBeDefined()
     expect(recoverySigner!.status).toBe('ready')
-    1
+
     // Handle the recovery signer
     const result4 = await (recoverySigner as SignerReady).handle()
     expect(result4).toBeDefined()
@@ -303,9 +303,9 @@ describe('Recovery', () => {
     })
 
     // Set up mnemonic handler and sign the payload
-    let handledMnemonic2 = 0
+    let _handledMnemonic2 = 0
     const unregisterHandler = manager.registerMnemonicUI(async (respond) => {
-      handledMnemonic2++
+      _handledMnemonic2++
       await respond(mnemonic2)
     })
 

package/test/sessions.test.ts

@@ -358,7 +358,7 @@ for (const extension of ALL_EXTENSIONS) {
         throw new Error('Failed to create pk store')
       }
       // Create the initial permissions
-      let explicitSession: ExplicitSession = {
+      const explicitSession: ExplicitSession = {
         type: 'explicit',
         sessionAddress: e.address,
         chainId,