@0xsequence/wallet-core 3.0.0-beta.9 → 3.0.1

package/src/signers/pk/encrypted.ts

@@ -1,4 +1,5 @@
 import { Hex, Address, PublicKey, Secp256k1, Bytes } from 'ox'
+import { resolveCoreEnv, type CoreEnv, type CryptoLike, type StorageLike, type TextEncodingLike } from '../../env.js'
 import { PkStore } from './index.js'
 
 export interface EncryptedData {
@@ -17,6 +18,7 @@ export class EncryptedPksDb {
   constructor(
     private readonly localStorageKeyPrefix: string = 'e_pk_key_',
     tableName: string = 'e_pk',
+    private readonly env?: CoreEnv,
   ) {
     this.tableName = tableName
   }
@@ -25,9 +27,59 @@ export class EncryptedPksDb {
     return `pk_${address.toLowerCase()}`
   }
 
+  private getIndexedDB(): IDBFactory {
+    const globalObj = globalThis as any
+    const indexedDb = this.env?.indexedDB ?? globalObj.indexedDB ?? globalObj.window?.indexedDB
+    if (!indexedDb) {
+      throw new Error('indexedDB is not available')
+    }
+    return indexedDb
+  }
+
+  private getStorage(): StorageLike {
+    const storage = resolveCoreEnv(this.env).storage
+    if (!storage) {
+      throw new Error('storage is not available')
+    }
+    return storage
+  }
+
+  private getCrypto(): CryptoLike {
+    const globalObj = globalThis as any
+    const crypto = this.env?.crypto ?? globalObj.crypto ?? globalObj.window?.crypto
+    if (!crypto?.subtle || !crypto?.getRandomValues) {
+      throw new Error('crypto.subtle is not available')
+    }
+    return crypto
+  }
+
+  private getTextEncoderCtor(): TextEncodingLike['TextEncoder'] {
+    const globalObj = globalThis as any
+    if (this.env?.text && (!this.env.text.TextEncoder || !this.env.text.TextDecoder)) {
+      throw new Error('env.text must provide both TextEncoder and TextDecoder')
+    }
+    const encoderCtor = this.env?.text?.TextEncoder ?? globalObj.TextEncoder ?? globalObj.window?.TextEncoder
+    if (!encoderCtor) {
+      throw new Error('TextEncoder is not available')
+    }
+    return encoderCtor
+  }
+
+  private getTextDecoderCtor(): TextEncodingLike['TextDecoder'] {
+    const globalObj = globalThis as any
+    if (this.env?.text && (!this.env.text.TextEncoder || !this.env.text.TextDecoder)) {
+      throw new Error('env.text must provide both TextEncoder and TextDecoder')
+    }
+    const decoderCtor = this.env?.text?.TextDecoder ?? globalObj.TextDecoder ?? globalObj.window?.TextDecoder
+    if (!decoderCtor) {
+      throw new Error('TextDecoder is not available')
+    }
+    return decoderCtor
+  }
+
   private openDB(): Promise<IDBDatabase> {
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, this.dbVersion)
+      const request = this.getIndexedDB().open(this.dbName, this.dbVersion)
       request.onupgradeneeded = () => {
         const db = request.result
         if (!db.objectStoreNames.contains(this.tableName)) {
@@ -73,7 +125,11 @@ export class EncryptedPksDb {
   }
 
   async generateAndStore(): Promise<EncryptedData> {
-    const encryptionKey = await window.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, [
+    const crypto = this.getCrypto()
+    const storage = this.getStorage()
+    const TextEncoderCtor = this.getTextEncoderCtor()
+
+    const encryptionKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, [
       'encrypt',
       'decrypt',
     ])
@@ -84,13 +140,13 @@ export class EncryptedPksDb {
     const address = Address.fromPublicKey(publicKey)
     const keyPointer = this.localStorageKeyPrefix + address
 
-    const exportedKey = await window.crypto.subtle.exportKey('jwk', encryptionKey)
-    window.localStorage.setItem(keyPointer, JSON.stringify(exportedKey))
+    const exportedKey = await crypto.subtle.exportKey('jwk', encryptionKey)
+    storage.setItem(keyPointer, JSON.stringify(exportedKey))
 
-    const encoder = new TextEncoder()
+    const encoder = new TextEncoderCtor()
     const encodedPk = encoder.encode(privateKey)
-    const iv = window.crypto.getRandomValues(new Uint8Array(12))
-    const encryptedBuffer = await window.crypto.subtle.encrypt({ name: 'AES-GCM', iv }, encryptionKey, encodedPk)
+    const iv = crypto.getRandomValues(new Uint8Array(12))
+    const encryptedBuffer = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, encryptionKey, encodedPk)
 
     const encrypted: EncryptedData = {
       iv,
@@ -113,7 +169,7 @@ export class EncryptedPksDb {
   async getEncryptedPkStore(address: Address.Address): Promise<EncryptedPkStore | undefined> {
     const entry = await this.getEncryptedEntry(address)
     if (!entry) return
-    return new EncryptedPkStore(entry)
+    return new EncryptedPkStore(entry, this.env)
   }
 
   async listAddresses(): Promise<Address.Address[]> {
@@ -125,12 +181,41 @@ export class EncryptedPksDb {
     const dbKey = this.computeDbKey(address)
     await this.putData(dbKey, undefined)
     const keyPointer = this.localStorageKeyPrefix + address
-    window.localStorage.removeItem(keyPointer)
+    this.getStorage().removeItem(keyPointer)
   }
 }
 
 export class EncryptedPkStore implements PkStore {
-  constructor(private readonly encrypted: EncryptedData) {}
+  constructor(
+    private readonly encrypted: EncryptedData,
+    private readonly env?: CoreEnv,
+  ) {}
+
+  private getStorage(): StorageLike {
+    const storage = resolveCoreEnv(this.env).storage
+    if (!storage) {
+      throw new Error('storage is not available')
+    }
+    return storage
+  }
+
+  private getCrypto(): CryptoLike {
+    const globalObj = globalThis as any
+    const crypto = this.env?.crypto ?? globalObj.crypto ?? globalObj.window?.crypto
+    if (!crypto?.subtle) {
+      throw new Error('crypto.subtle is not available')
+    }
+    return crypto
+  }
+
+  private getTextDecoderCtor(): TextEncodingLike['TextDecoder'] {
+    const globalObj = globalThis as any
+    const decoderCtor = this.env?.text?.TextDecoder ?? globalObj.TextDecoder ?? globalObj.window?.TextDecoder
+    if (!decoderCtor) {
+      throw new Error('TextDecoder is not available')
+    }
+    return decoderCtor
+  }
 
   address(): Address.Address {
     return this.encrypted.address
@@ -141,16 +226,20 @@ export class EncryptedPkStore implements PkStore {
   }
 
   async signDigest(digest: Bytes.Bytes): Promise<{ r: bigint; s: bigint; yParity: number }> {
-    const keyJson = window.localStorage.getItem(this.encrypted.keyPointer)
+    const storage = this.getStorage()
+    const crypto = this.getCrypto()
+    const TextDecoderCtor = this.getTextDecoderCtor()
+
+    const keyJson = storage.getItem(this.encrypted.keyPointer)
     if (!keyJson) throw new Error('Encryption key not found in localStorage')
     const jwk = JSON.parse(keyJson)
-    const encryptionKey = await window.crypto.subtle.importKey('jwk', jwk, { name: 'AES-GCM' }, false, ['decrypt'])
-    const decryptedBuffer = await window.crypto.subtle.decrypt(
+    const encryptionKey = await crypto.subtle.importKey('jwk', jwk, { name: 'AES-GCM' }, false, ['decrypt'])
+    const decryptedBuffer = await crypto.subtle.decrypt(
       { name: 'AES-GCM', iv: this.encrypted.iv },
       encryptionKey,
       this.encrypted.data,
     )
-    const decoder = new TextDecoder()
+    const decoder = new TextDecoderCtor()
     const privateKey = decoder.decode(decryptedBuffer) as Hex.Hex
     return Secp256k1.sign({ payload: digest, privateKey })
   }

package/src/signers/pk/index.ts

@@ -52,7 +52,7 @@ export class Pk implements SignerInterface, Witnessable {
     return { ...signature, type: 'hash' }
   }
 
-  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/signers/session/explicit.ts

@@ -1,14 +1,7 @@
-import {
-  Constants,
-  Extensions,
-  Payload,
-  Permission,
-  SessionConfig,
-  SessionSignature,
-} from '@0xsequence/wallet-primitives'
+import { Constants, Payload, Permission, SessionConfig, SessionSignature } from '@0xsequence/wallet-primitives'
 import { AbiFunction, AbiParameters, Address, Bytes, Hash, Hex, Provider } from 'ox'
 import { MemoryPkStore, PkStore } from '../pk/index.js'
-import { ExplicitSessionSigner, SessionSignerValidity, UsageLimit } from './session.js'
+import { ExplicitSessionSigner, isIncrementCall, SessionSignerValidity, UsageLimit } from './session.js'
 
 export type ExplicitParams = Omit<Permission.SessionPermissions, 'signer'>
 
@@ -215,11 +208,7 @@ export class Explicit implements ExplicitSessionSigner {
     sessionManagerAddress: Address.Address,
     provider?: Provider.Provider,
   ): Promise<boolean> {
-    if (
-      Address.isEqual(call.to, sessionManagerAddress) &&
-      Hex.size(call.data) > 4 &&
-      Hex.isEqual(Hex.slice(call.data, 0, 4), AbiFunction.getSelector(Constants.INCREMENT_USAGE_LIMIT))
-    ) {
+    if (isIncrementCall(call, sessionManagerAddress)) {
       // Can sign increment usage calls
       return true
     }
@@ -241,11 +230,7 @@ export class Explicit implements ExplicitSessionSigner {
   ): Promise<SessionSignature.SessionCallSignature> {
     const call = payload.calls[callIdx]!
     let permissionIndex: number
-    if (
-      Address.isEqual(call.to, sessionManagerAddress) &&
-      Hex.size(call.data) > 4 &&
-      Hex.isEqual(Hex.slice(call.data, 0, 4), AbiFunction.getSelector(Constants.INCREMENT_USAGE_LIMIT))
-    ) {
+    if (isIncrementCall(call, sessionManagerAddress)) {
       // Permission check not required. Use the first permission
       permissionIndex = 0
     } else {
@@ -323,7 +308,7 @@ export class Explicit implements ExplicitSessionSigner {
           Bytes.fromHex(call.data).slice(Number(rule.offset), Number(rule.offset) + 32),
           32,
         )
-        let value: Bytes.Bytes = callDataValue.map((b, i) => b & rule.mask[i]!)
+        const value: Bytes.Bytes = callDataValue.map((b, i) => b & rule.mask[i]!)
         if (Bytes.toBigInt(value) === 0n) continue
 
         // Add to list

package/src/signers/session/implicit.ts

@@ -1,6 +1,5 @@
 import {
   Attestation,
-  Extensions,
   Payload,
   Signature as SequenceSignature,
   SessionConfig,
@@ -96,7 +95,7 @@ export class Implicit implements ImplicitSessionSigner {
       )
       const expectedResult = Bytes.toHex(Attestation.generateImplicitRequestMagic(this._attestation, wallet))
       return acceptImplicitRequest === expectedResult
-    } catch (error) {
+    } catch {
       // console.log('implicit signer unsupported call', call, error)
       return false
     }

package/src/signers/session/session.ts

@@ -1,5 +1,5 @@
-import { Payload, SessionConfig, SessionSignature } from '@0xsequence/wallet-primitives'
-import { Address, Hex, Provider } from 'ox'
+import { Constants, Payload, SessionConfig, SessionSignature } from '@0xsequence/wallet-primitives'
+import { AbiFunction, Address, Hex, Provider } from 'ox'
 
 export type SessionSignerInvalidReason =
   | 'Expired'
@@ -68,3 +68,11 @@ export function isExplicitSessionSigner(signer: SessionSigner): signer is Explic
 export function isImplicitSessionSigner(signer: SessionSigner): signer is ImplicitSessionSigner {
   return 'identitySigner' in signer
 }
+
+export function isIncrementCall(call: Payload.Call, sessionManagerAddress: Address.Address): boolean {
+  return (
+    Address.isEqual(call.to, sessionManagerAddress) &&
+    Hex.size(call.data) >= 4 &&
+    Hex.isEqual(Hex.slice(call.data, 0, 4), AbiFunction.getSelector(Constants.INCREMENT_USAGE_LIMIT))
+  )
+}

package/src/signers/session-manager.ts

@@ -18,6 +18,7 @@ import {
   SessionSigner,
   SessionSignerInvalidReason,
   isImplicitSessionSigner,
+  isIncrementCall,
   UsageLimit,
 } from './session/index.js'
 
@@ -130,21 +131,16 @@ export class SessionManager implements SapientSigner {
     }))
   }
 
-  async findSignersForCalls(wallet: Address.Address, chainId: number, calls: Payload.Call[]): Promise<SessionSigner[]> {
-    // Only use signers that match the topology
-    const topology = await this.topology
-    const identitySigners = SessionConfig.getIdentitySigners(topology)
-    if (identitySigners.length === 0) {
-      throw new Error('Identity signers not found')
-    }
-
-    // Prioritize implicit signers
-    const availableSigners = [...this._implicitSigners, ...this._explicitSigners]
-    if (availableSigners.length === 0) {
-      throw new Error('No signers match the topology')
-    }
-
-    // Find supported signers for each call
+  /**
+   * Find one signer per call from the given candidate list (first that supports each call).
+   */
+  private async findSignersForCallsWithCandidates(
+    wallet: Address.Address,
+    chainId: number,
+    calls: Payload.Call[],
+    topology: SessionConfig.SessionsTopology,
+    availableSigners: SessionSigner[],
+  ): Promise<SessionSigner[]> {
     const signers: SessionSigner[] = []
     for (const call of calls) {
       let supported = false
@@ -173,9 +169,67 @@ export class SessionManager implements SapientSigner {
         if (expiredSupportedSigner) {
           throw new Error(`Signer supporting call is expired: ${expiredSupportedSigner.address}`)
         }
-        throw new Error(
-          `No signer supported for call. ` + `Call: to=${call.to}, data=${call.data}, value=${call.value}, `,
-        )
+        throw new Error(`No signer supported for call. Call: to=${call.to}, data=${call.data}, value=${call.value}, `)
+      }
+    }
+    return signers
+  }
+
+  async findSignersForCalls(wallet: Address.Address, chainId: number, calls: Payload.Call[]): Promise<SessionSigner[]> {
+    const topology = await this.topology
+    const identitySigners = SessionConfig.getIdentitySigners(topology)
+    if (identitySigners.length === 0) {
+      throw new Error('Identity signers not found')
+    }
+
+    const availableSigners = [...this._implicitSigners, ...this._explicitSigners]
+    if (availableSigners.length === 0) {
+      throw new Error('No signers match the topology')
+    }
+
+    const nonIncrementCalls: Payload.Call[] = []
+    const incrementCalls: Payload.Call[] = []
+    for (const call of calls) {
+      if (isIncrementCall(call, this.address)) {
+        incrementCalls.push(call)
+      } else {
+        nonIncrementCalls.push(call)
+      }
+    }
+
+    // Find signers for non-increment calls
+    const nonIncrementSigners =
+      nonIncrementCalls.length > 0
+        ? await this.findSignersForCallsWithCandidates(wallet, chainId, nonIncrementCalls, topology, availableSigners)
+        : []
+
+    let incrementSigners: SessionSigner[] = []
+    if (incrementCalls.length > 0) {
+      // Find signers for increment calls, preferring signers that signed non-increment calls
+      const incrementCandidates = [
+        ...nonIncrementSigners,
+        ...availableSigners.filter((s) => !nonIncrementSigners.includes(s)),
+      ]
+      incrementSigners = await this.findSignersForCallsWithCandidates(
+        wallet,
+        chainId,
+        incrementCalls,
+        topology,
+        incrementCandidates,
+      )
+    }
+
+    // Merge back in original call order
+    const signers: SessionSigner[] = []
+    let nonIncrementIndex = 0
+    let incrementIndex = 0
+    for (const call of calls) {
+      if (isIncrementCall(call, this.address)) {
+        signers.push(incrementSigners[incrementIndex]!)
+        incrementIndex++
+      } else {
+        signers.push(nonIncrementSigners[nonIncrementIndex]!)
+        nonIncrementIndex++
       }
     }
     return signers
@@ -191,20 +245,23 @@ export class SessionManager implements SapientSigner {
     }
     const signers = await this.findSignersForCalls(wallet, chainId, calls)
 
-    // Create a map of signers to their associated calls
-    const signerToCalls = new Map<SessionSigner, Payload.Call[]>()
+    // Map each signer to only their non-increment calls
+    const signerToNonIncrementCalls = new Map<SessionSigner, Payload.Call[]>()
     signers.forEach((signer, index) => {
       const call = calls[index]!
-      const existingCalls = signerToCalls.get(signer) || []
-      signerToCalls.set(signer, [...existingCalls, call])
+      if (isIncrementCall(call, this.address)) {
+        return
+      }
+      const existing = signerToNonIncrementCalls.get(signer) || []
+      signerToNonIncrementCalls.set(signer, [...existing, call])
     })
 
-    // Prepare increments for each explicit signer with their associated calls
+    // Prepare increments for each explicit signer from their non-increment calls only
     const increments: UsageLimit[] = (
       await Promise.all(
-        Array.from(signerToCalls.entries()).map(async ([signer, associatedCalls]) => {
+        Array.from(signerToNonIncrementCalls.entries()).map(async ([signer, nonIncrementCalls]) => {
           if (isExplicitSessionSigner(signer)) {
-            return signer.prepareIncrements(wallet, chainId, associatedCalls, this.address, this._provider!)
+            return signer.prepareIncrements(wallet, chainId, nonIncrementCalls, this.address, this._provider!)
           }
           return []
         }),

package/src/state/local/index.ts

@@ -203,7 +203,7 @@ export class Provider implements ProviderInterface {
     fromImageHash: Hex.Hex,
     options?: { allUpdates?: boolean },
   ): Promise<{ imageHash: Hex.Hex; signature: Signature.RawSignature }[]> {
-    let fromConfig = await this.store.loadConfig(fromImageHash)
+    const fromConfig = await this.store.loadConfig(fromImageHash)
     if (!fromConfig) {
       return []
     }
@@ -384,7 +384,7 @@ export class Provider implements ProviderInterface {
 
       if (Signature.isSignatureOfSapientSignerLeaf(topology.signature)) {
         switch (topology.signature.address.toLowerCase()) {
-          case this.extensions.passkeys.toLowerCase():
+          case this.extensions.passkeys.toLowerCase(): {
             const decoded = Extensions.Passkeys.decode(Bytes.fromHex(topology.signature.data))
 
             if (!Extensions.Passkeys.isValidSignature(subdigest, decoded)) {
@@ -397,6 +397,8 @@ export class Provider implements ProviderInterface {
               Extensions.Passkeys.rootFor(decoded.publicKey),
               topology.signature,
             )
+          }
+
           default:
             throw new Error(`Unsupported sapient signer: ${topology.signature.address}`)
         }

package/src/state/local/indexed-db.ts

@@ -1,5 +1,6 @@
 import { Context, Payload, Signature, Config, GenericTree } from '@0xsequence/wallet-primitives'
 import { Address, Hex } from 'ox'
+import type { CoreEnv } from '../../env.js'
 import { Store } from './index.js'
 
 const DB_VERSION = 1
@@ -16,15 +17,27 @@ export class IndexedDbStore implements Store {
   private _db: IDBDatabase | null = null
   private dbName: string
 
-  constructor(dbName: string = 'sequence-indexeddb') {
+  constructor(
+    dbName: string = 'sequence-indexeddb',
+    private readonly env?: CoreEnv,
+  ) {
     this.dbName = dbName
   }
 
+  private getIndexedDB(): IDBFactory {
+    const globalObj = globalThis as any
+    const indexedDb = this.env?.indexedDB ?? globalObj.indexedDB ?? globalObj.window?.indexedDB
+    if (!indexedDb) {
+      throw new Error('indexedDB is not available')
+    }
+    return indexedDb
+  }
+
   private async openDB(): Promise<IDBDatabase> {
     if (this._db) return this._db
 
     return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, DB_VERSION)
+      const request = this.getIndexedDB().open(this.dbName, DB_VERSION)
 
       request.onupgradeneeded = () => {
         const db = request.result

package/src/state/remote/dev-http.ts

@@ -4,10 +4,16 @@ import { Provider } from '../index.js'
 
 export class DevHttpProvider implements Provider {
   private readonly baseUrl: string
+  private readonly fetcher: typeof fetch
 
-  constructor(baseUrl: string) {
+  constructor(baseUrl: string, fetcher?: typeof fetch) {
     // Remove trailing slash if present
     this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
+    const resolvedFetch = fetcher ?? (globalThis as any).fetch
+    if (!resolvedFetch) {
+      throw new Error('fetch is not available')
+    }
+    this.fetcher = resolvedFetch
   }
 
   private async request<T>(method: 'GET' | 'POST', path: string, body?: any): Promise<T> {
@@ -24,7 +30,7 @@ export class DevHttpProvider implements Provider {
 
     let response: Response
     try {
-      response = await fetch(url, options)
+      response = await this.fetcher(url, options)
     } catch (networkError) {
       // Handle immediate network errors (e.g., DNS resolution failure, refused connection)
       console.error(`Network error during ${method} request to ${url}:`, networkError)
@@ -38,12 +44,12 @@ export class DevHttpProvider implements Provider {
         const errorText = await response.text()
         const errorJson = await Utils.fromJSON(errorText)
         errorPayload = { ...errorPayload, ...errorJson }
-      } catch (e) {
+      } catch {
         try {
           // If JSON parsing fails, try getting text for better error message
           const errorText = await response.text()
           errorPayload.body = errorText
-        } catch (textErr) {
+        } catch {
           // Ignore if reading text also fails
         }
       }
@@ -99,7 +105,7 @@ export class DevHttpProvider implements Provider {
         throw new Error(
           `Failed to parse JSON response from server. Status: ${response.status}. Body: "${text}". Original error: ${error instanceof Error ? error.message : String(error)}`,
         )
-      } catch (readError) {
+      } catch {
         throw new Error(
           `Failed to parse JSON response from server and could not read response body as text. Status: ${response.status}. Original error: ${error instanceof Error ? error.message : String(error)}`,
         )

package/src/state/sequence/index.ts

@@ -9,13 +9,17 @@ import {
   TransactionRequest,
 } from 'ox'
 import { normalizeAddressKeys, Provider as ProviderInterface } from '../index.js'
-import { Sessions, SignatureType } from './sessions.gen.js'
+import { Sessions, SignatureType, type Fetch } from './sessions.gen.js'
 
 export class Provider implements ProviderInterface {
   private readonly service: Sessions
 
-  constructor(host = 'https://keymachine.sequence.app') {
-    this.service = new Sessions(host, fetch)
+  constructor(host = 'https://keymachine.sequence.app', fetcher?: Fetch) {
+    const resolvedFetch = fetcher ?? (globalThis as any).fetch
+    if (!resolvedFetch) {
+      throw new Error('fetch is not available')
+    }
+    this.service = new Sessions(host, resolvedFetch)
   }
 
   async getConfiguration(imageHash: Hex.Hex): Promise<Config.Config | undefined> {
@@ -186,7 +190,9 @@ export class Provider implements ProviderInterface {
         case SignatureType.SapientCompact:
           throw new Error(`unexpected compact sapient signature by ${signer}`)
       }
-    } catch {}
+    } catch {
+      // ignore
+    }
   }
 
   async getWitnessForSapient(
@@ -221,7 +227,9 @@ export class Provider implements ProviderInterface {
             signature: { type: 'sapient_compact', address: signer, data: witness.signature },
           }
       }
-    } catch {}
+    } catch {
+      // ignore
+    }
   }
 
   async getConfigurationUpdates(
@@ -380,7 +388,7 @@ const recoverSapientSignatureCompactFunction = AbiFunction.from(recoverSapientSi
 class PasskeySignatureValidator implements oxProvider.Provider {
   request: oxProvider.Provider['request'] = (async (request) => {
     switch (request.method) {
-      case 'eth_call':
+      case 'eth_call': {
         if (!request.params || !Array.isArray(request.params) || request.params.length === 0) {
           throw new Error('eth_call requires transaction parameters')
         }
@@ -406,6 +414,7 @@ class PasskeySignatureValidator implements oxProvider.Provider {
         } else {
           throw new Error(`invalid passkey signature ${signature} for digest ${digest}`)
         }
+      }
 
       default:
         throw new Error(`method ${request.method} not implemented`)

package/src/wallet.ts

@@ -355,7 +355,7 @@ export class Wallet {
       throw new Error('4337 is not enabled in this wallet')
     }
 
-    const noncePromise = this.get4337Nonce(provider, status.context.capabilities?.erc4337?.entrypoint!, space)
+    const noncePromise = this.get4337Nonce(provider, status.context.capabilities.erc4337.entrypoint, space)
 
     // If the wallet is not deployed, then we need to include the initCode on
     // the 4337 transaction
@@ -570,7 +570,7 @@ export class Wallet {
     if (typeof message !== 'string') {
       encodedMessage = TypedData.encode(message)
     } else {
-      let hexMessage = Hex.validate(message) ? message : Hex.fromString(message)
+      const hexMessage = Hex.validate(message) ? message : Hex.fromString(message)
       const messageSize = Hex.size(hexMessage)
       encodedMessage = Hex.concat(Hex.fromString(`${`\x19Ethereum Signed Message:\n${messageSize}`}`), hexMessage)
     }

package/test/constants.ts

@@ -1,9 +1,12 @@
 import { config as dotenvConfig } from 'dotenv'
 import { Abi, AbiEvent, Address } from 'ox'
 
+// eslint-disable-next-line turbo/no-undeclared-env-vars
 const envFile = process.env.CI ? '.env.test' : '.env.test.local'
 dotenvConfig({ path: envFile })
 
+// Contracts are deployed on Arbitrum
+
 // Requires https://example.com redirectUrl
 export const EMITTER_ADDRESS1: Address.Address = '0xad90eB52BC180Bd9f66f50981E196f3E996278D3'
 // Requires https://another-example.com redirectUrl
@@ -16,4 +19,5 @@ export const EMITTER_EVENT_TOPICS = [
 export const USDC_ADDRESS: Address.Address = '0xaf88d065e77c8cc2239327c5edb3a432268e5831'
 
 // Environment variables
+// eslint-disable-next-line turbo/no-undeclared-env-vars
 export const LOCAL_RPC_URL = process.env.LOCAL_RPC_URL || 'http://localhost:8545'

package/test/envelope.test.ts

@@ -6,7 +6,6 @@ import * as Envelope from '../src/envelope.js'
 
 // Test addresses and data
 const TEST_ADDRESS_1 = Address.from('0x1234567890123456789012345678901234567890')
-const TEST_ADDRESS_2 = Address.from('0xabcdefabcdefabcdefabcdefabcdefabcdefabcd')
 const TEST_ADDRESS_3 = Address.from('0x9876543210987654321098765432109876543210')
 const TEST_WALLET = Address.from('0xfedcbafedcbafedcbafedcbafedcbafedcbafe00')
 const TEST_IMAGE_HASH = Hex.from('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')