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

package/src/env.ts

@@ -0,0 +1,68 @@
+export type StorageLike = {
+  getItem: (key: string) => string | null
+  setItem: (key: string, value: string) => void
+  removeItem: (key: string) => void
+}
+
+export type CryptoLike = {
+  subtle: SubtleCrypto
+  getRandomValues: <T extends ArrayBufferView>(array: T) => T
+}
+
+export type TextEncodingLike = {
+  TextEncoder: typeof TextEncoder
+  TextDecoder: typeof TextDecoder
+}
+
+export type CoreEnv = {
+  fetch?: typeof fetch
+  crypto?: CryptoLike
+  storage?: StorageLike
+  indexedDB?: IDBFactory
+  text?: Partial<TextEncodingLike>
+}
+
+function isStorageLike(value: unknown): value is StorageLike {
+  if (!value || typeof value !== 'object') return false
+  const candidate = value as StorageLike
+  return (
+    typeof candidate.getItem === 'function' &&
+    typeof candidate.setItem === 'function' &&
+    typeof candidate.removeItem === 'function'
+  )
+}
+
+export function resolveCoreEnv(env?: CoreEnv): CoreEnv {
+  const globalObj = globalThis as any
+  const windowObj = typeof window !== 'undefined' ? window : (globalObj.window ?? {})
+  let storage: StorageLike | undefined
+  let text: Partial<TextEncodingLike> | undefined
+
+  if (isStorageLike(env?.storage)) {
+    storage = env.storage
+  } else if (isStorageLike(windowObj.localStorage)) {
+    storage = windowObj.localStorage
+  } else if (isStorageLike(globalObj.localStorage)) {
+    storage = globalObj.localStorage
+  }
+
+  if (env?.text) {
+    if (!env.text.TextEncoder || !env.text.TextDecoder) {
+      throw new Error('env.text must provide both TextEncoder and TextDecoder')
+    }
+    text = env.text
+  } else {
+    text = {
+      TextEncoder: windowObj.TextEncoder ?? globalObj.TextEncoder,
+      TextDecoder: windowObj.TextDecoder ?? globalObj.TextDecoder,
+    }
+  }
+
+  return {
+    fetch: env?.fetch ?? windowObj.fetch ?? globalObj.fetch,
+    crypto: env?.crypto ?? windowObj.crypto ?? globalObj.crypto,
+    storage,
+    indexedDB: env?.indexedDB ?? windowObj.indexedDB ?? globalObj.indexedDB,
+    text,
+  }
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export * as State from './state/index.js'
 export * as Bundler from './bundler/index.js'
 export * as Envelope from './envelope.js'
 export * as Utils from './utils/index.js'
+export * from './env.js'
 export {
   type ExplicitSessionConfig,
   type ExplicitSession,

package/src/signers/index.ts

@@ -31,7 +31,7 @@ export interface SapientSigner {
 }
 
 export interface Witnessable {
-  witness: (stateWriter: State.Writer, wallet: Address.Address, extra?: Object) => Promise<void>
+  witness: (stateWriter: State.Writer, wallet: Address.Address, extra?: object) => Promise<void>
 }
 
 type MaybePromise<T> = T | Promise<T>

package/src/signers/passkey.ts

@@ -5,12 +5,15 @@ import { WebAuthnP256 } from 'ox'
 import { State } from '../index.js'
 import { SapientSigner, Witnessable } from './index.js'
 
+export type WebAuthnLike = Pick<typeof WebAuthnP256, 'createCredential' | 'sign'>
+
 export type PasskeyOptions = {
   extensions: Pick<Extensions.Extensions, 'passkeys'>
   publicKey: Extensions.Passkeys.PublicKey
   credentialId: string
   embedMetadata?: boolean
   metadata?: Extensions.Passkeys.PasskeyMetadata
+  webauthn?: WebAuthnLike
 }
 
 export type CreatePasskeyOptions = {
@@ -18,6 +21,11 @@ export type CreatePasskeyOptions = {
   requireUserVerification?: boolean
   credentialName?: string
   embedMetadata?: boolean
+  webauthn?: WebAuthnLike
+}
+
+export type FindPasskeyOptions = {
+  webauthn?: WebAuthnLike
 }
 
 export type WitnessMessage = {
@@ -45,6 +53,7 @@ export class Passkey implements SapientSigner, Witnessable {
   public readonly imageHash: Hex.Hex
   public readonly embedMetadata: boolean
   public readonly metadata?: Extensions.Passkeys.PasskeyMetadata
+  private readonly webauthn: WebAuthnLike
 
   constructor(options: PasskeyOptions) {
     this.address = options.extensions.passkeys
@@ -53,6 +62,7 @@ export class Passkey implements SapientSigner, Witnessable {
     this.embedMetadata = options.embedMetadata ?? false
     this.imageHash = Extensions.Passkeys.rootFor(options.publicKey)
     this.metadata = options.metadata
+    this.webauthn = options.webauthn ?? WebAuthnP256
   }
 
   static async loadFromWitness(
@@ -60,6 +70,7 @@ export class Passkey implements SapientSigner, Witnessable {
     extensions: Pick<Extensions.Extensions, 'passkeys'>,
     wallet: Address.Address,
     imageHash: Hex.Hex,
+    options?: FindPasskeyOptions,
   ) {
     // In the witness we will find the public key, and may find the credential id
     const witness = await stateReader.getWitnessForSapient(wallet, extensions.passkeys, imageHash)
@@ -90,13 +101,15 @@ export class Passkey implements SapientSigner, Witnessable {
       publicKey: message.publicKey,
       embedMetadata: decodedSignature.embedMetadata,
       metadata,
+      webauthn: options?.webauthn,
     })
   }
 
   static async create(extensions: Pick<Extensions.Extensions, 'passkeys'>, options?: CreatePasskeyOptions) {
+    const webauthn = options?.webauthn ?? WebAuthnP256
     const name = options?.credentialName ?? `Sequence (${Date.now()})`
 
-    const credential = await WebAuthnP256.createCredential({
+    const credential = await webauthn.createCredential({
       user: {
         name,
       },
@@ -120,6 +133,7 @@ export class Passkey implements SapientSigner, Witnessable {
       },
       embedMetadata: options?.embedMetadata,
       metadata,
+      webauthn,
     })
 
     if (options?.stateProvider) {
@@ -132,8 +146,10 @@ export class Passkey implements SapientSigner, Witnessable {
   static async find(
     stateReader: State.Reader,
     extensions: Pick<Extensions.Extensions, 'passkeys'>,
+    options?: FindPasskeyOptions,
   ): Promise<Passkey | undefined> {
-    const response = await WebAuthnP256.sign({ challenge: Hex.random(32) })
+    const webauthn = options?.webauthn ?? WebAuthnP256
+    const response = await webauthn.sign({ challenge: Hex.random(32) })
     if (!response.raw) throw new Error('No credential returned')
 
     const authenticatorDataBytes = Bytes.fromHex(response.metadata.authenticatorData)
@@ -218,7 +234,7 @@ export class Passkey implements SapientSigner, Witnessable {
       console.warn('Multiple signers found for passkey', flattened)
     }
 
-    return Passkey.loadFromWitness(stateReader, extensions, flattened[0]!.wallet, flattened[0]!.imageHash)
+    return Passkey.loadFromWitness(stateReader, extensions, flattened[0]!.wallet, flattened[0]!.imageHash, options)
   }
 
   async signSapient(
@@ -234,7 +250,7 @@ export class Passkey implements SapientSigner, Witnessable {
 
     const challenge = Hex.fromBytes(Payload.hash(wallet, chainId, payload))
 
-    const response = await WebAuthnP256.sign({
+    const response = await this.webauthn.sign({
       challenge,
       credentialId: this.credentialId,
       userVerification: this.publicKey.requireUserVerification ? 'required' : 'discouraged',
@@ -260,7 +276,7 @@ export class Passkey implements SapientSigner, Witnessable {
     }
   }
 
-  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/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,11 +1,4 @@
-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'
@@ -323,7 +316,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/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,6 +1,7 @@
 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 })
 
@@ -16,4 +17,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')

package/test/signers-pk.test.ts

@@ -143,7 +143,7 @@ describe('Private Key Signers', () => {
         await pk.witness(mockStateWriter, testWallet)
 
         expect(mockStateWriter.saveWitnesses).toHaveBeenCalledTimes(1)
-        const [wallet, chainId, payload, witness] = vi.mocked(mockStateWriter.saveWitnesses).mock.calls[0]
+        const [wallet, chainId, _payload, witness] = vi.mocked(mockStateWriter.saveWitnesses).mock.calls[0]
 
         expect(wallet).toBe(testWallet)
         expect(chainId).toBe(0)

package/test/signers-session-implicit.test.ts

@@ -236,7 +236,6 @@ describe('Implicit Session', () => {
         },
       }
       const identitySignature = createValidIdentitySignature(attestation)
-      const topology = createValidTopology()
 
       // This should throw an error during construction due to future issued time
       expect(() => {
@@ -250,7 +249,6 @@ describe('Implicit Session', () => {
         approvedSigner: randomAddress(), // Different approved signer
       }
       const identitySignature = createValidIdentitySignature(attestation)
-      const topology = createValidTopology()
 
       // This should throw an error during construction due to mismatched approved signer
       expect(() => {