@0xsequence/wallet-wdk 0.0.0-20250520201059

package/src/dbs/auth-keys.ts

@@ -0,0 +1,85 @@
+import { Generic } from './generic.js'
+
+const TABLE_NAME = 'auth-keys'
+
+export type AuthKey = {
+  address: string
+  privateKey: CryptoKey
+  identitySigner: string
+  expiresAt: Date
+}
+
+export class AuthKeys extends Generic<AuthKey, 'address'> {
+  private expirationTimers = new Map<string, number>()
+
+  constructor(dbName: string = 'sequence-auth-keys') {
+    super(dbName, TABLE_NAME, 'address', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          const store = db.createObjectStore(TABLE_NAME)
+          store.createIndex('identitySigner', 'identitySigner', { unique: true })
+        }
+      },
+    ])
+  }
+
+  async handleOpenDB(): Promise<void> {
+    const authKeys = await this.list()
+    for (const authKey of authKeys) {
+      this.scheduleExpiration(authKey)
+    }
+  }
+
+  async set(item: AuthKey): Promise<AuthKey['address']> {
+    const result = await super.set(item)
+    this.scheduleExpiration(item)
+    return result
+  }
+
+  async del(address: AuthKey['address']): Promise<void> {
+    const result = await super.del(address)
+    this.clearExpiration(address)
+    return result
+  }
+
+  async getBySigner(signer: string): Promise<AuthKey | undefined> {
+    const store = await this.getStore('readonly')
+    const index = store.index('identitySigner')
+    return new Promise((resolve, reject) => {
+      const req = index.get(signer)
+      req.onsuccess = () => resolve(req.result)
+      req.onerror = () => reject(req.error)
+    })
+  }
+
+  async delBySigner(signer: string): Promise<void> {
+    const authKey = await this.getBySigner(signer)
+    if (authKey) {
+      await this.del(authKey.address)
+    }
+  }
+
+  private async scheduleExpiration(authKey: AuthKey): Promise<void> {
+    this.clearExpiration(authKey.address)
+
+    const now = Date.now()
+    const delay = authKey.expiresAt.getTime() - now
+    if (delay <= 0) {
+      await this.del(authKey.address)
+      return
+    }
+    const timer = window.setTimeout(() => {
+      console.log('removing expired auth key', authKey)
+      this.del(authKey.address)
+    }, delay)
+    this.expirationTimers.set(authKey.address, timer)
+  }
+
+  private clearExpiration(address: string): void {
+    const timer = this.expirationTimers.get(address)
+    if (timer) {
+      window.clearTimeout(timer)
+      this.expirationTimers.delete(address)
+    }
+  }
+}

package/src/dbs/generic.ts

@@ -0,0 +1,194 @@
+export type DbUpdateType = 'added' | 'updated' | 'removed'
+
+export type DbUpdateListener<T, K extends keyof T> = (
+  keyValue: T[K],
+  updateType: DbUpdateType,
+  oldItem?: T,
+  newItem?: T,
+) => void
+
+export type Migration = (db: IDBDatabase, transaction: IDBTransaction, event: IDBVersionChangeEvent) => void
+
+function deepEqual(a: any, b: any): boolean {
+  if (a === b) {
+    return true
+  }
+
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
+    return false
+  }
+
+  const keysA = Object.keys(a)
+  const keysB = Object.keys(b)
+  if (keysA.length !== keysB.length) return false
+
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false
+    if (!deepEqual(a[key], b[key])) return false
+  }
+
+  return true
+}
+
+export class Generic<T extends { [P in K]: IDBValidKey }, K extends keyof T> {
+  private _db: IDBDatabase | null = null
+  private listeners: DbUpdateListener<T, K>[] = []
+  private broadcastChannel?: BroadcastChannel
+
+  /**
+   * @param dbName The name of the IndexedDB database.
+   * @param storeName The name of the object store.
+   * @param key The property key in T to be used as the primary key.
+   * @param migrations An array of migration functions; the database version is migrations.length + 1.
+   */
+  constructor(
+    private dbName: string,
+    private storeName: string,
+    private key: K,
+    private migrations: Migration[] = [],
+  ) {
+    if (typeof BroadcastChannel !== 'undefined') {
+      this.broadcastChannel = new BroadcastChannel(this.dbName + '-observer')
+      this.broadcastChannel.onmessage = (event) => {
+        if (event.data && event.data.keyValue !== undefined && event.data.updateType) {
+          this.listeners.forEach((cb) =>
+            cb(event.data.keyValue, event.data.updateType, event.data.oldItem, event.data.newItem),
+          )
+        }
+      }
+    }
+  }
+
+  private async openDB(): Promise<IDBDatabase> {
+    if (this._db) return this._db
+
+    return new Promise((resolve, reject) => {
+      const version = this.migrations.length + 1
+      const request = indexedDB.open(this.dbName, version)
+
+      request.onupgradeneeded = (event) => {
+        const db = request.result
+        const tx = request.transaction!
+        const oldVersion = (event.oldVersion as number) || 0
+        for (let i = oldVersion; i < this.migrations.length; i++) {
+          const migration = this.migrations[i]
+          if (!migration) throw new Error(`Migration ${i} not found`)
+          migration(db, tx, event)
+        }
+      }
+
+      request.onsuccess = () => {
+        this._db = request.result
+        this.handleOpenDB().then(() => resolve(this._db!))
+      }
+
+      request.onerror = () => reject(request.error)
+      request.onblocked = () => console.error('Database upgrade blocked')
+    })
+  }
+
+  protected async handleOpenDB(): Promise<void> {}
+
+  protected async getStore(mode: IDBTransactionMode): Promise<IDBObjectStore> {
+    const db = await this.openDB()
+    const tx = db.transaction(this.storeName, mode)
+    return tx.objectStore(this.storeName)
+  }
+
+  async get(keyValue: T[K]): Promise<T | undefined> {
+    const store = await this.getStore('readonly')
+    return new Promise((resolve, reject) => {
+      const req = store.get(keyValue)
+      req.onsuccess = () => resolve(req.result as T)
+      req.onerror = () => reject(req.error)
+    })
+  }
+
+  async list(): Promise<T[]> {
+    const store = await this.getStore('readonly')
+    return new Promise((resolve, reject) => {
+      const req = store.getAll()
+      req.onsuccess = () => resolve(req.result as T[])
+      req.onerror = () => reject(req.error)
+    })
+  }
+
+  async set(item: T): Promise<T[K]> {
+    const db = await this.openDB()
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readwrite')
+      const store = tx.objectStore(this.storeName)
+      const keyValue = item[this.key]
+
+      const getReq = store.get(keyValue)
+      getReq.onsuccess = () => {
+        const oldItem = getReq.result
+        const putReq = store.put(item, keyValue)
+        putReq.onsuccess = () => {
+          let updateType: DbUpdateType | null = null
+          if (!oldItem) {
+            updateType = 'added'
+          } else if (!deepEqual(oldItem, item)) {
+            updateType = 'updated'
+          }
+          if (updateType) {
+            try {
+              this.notifyUpdate(keyValue, updateType, oldItem, item)
+            } catch (err) {
+              console.error('notifyUpdate failed', err)
+            }
+          }
+          resolve(keyValue)
+        }
+        putReq.onerror = () => reject(putReq.error)
+      }
+      getReq.onerror = () => reject(getReq.error)
+    })
+  }
+
+  async del(keyValue: T[K]): Promise<void> {
+    const oldItem = await this.get(keyValue)
+    const store = await this.getStore('readwrite')
+    return new Promise((resolve, reject) => {
+      const req = store.delete(keyValue)
+      req.onsuccess = () => {
+        if (oldItem) {
+          try {
+            this.notifyUpdate(keyValue, 'removed', oldItem, undefined)
+          } catch (err) {
+            console.error('notifyUpdate failed', err)
+          }
+        }
+        resolve()
+      }
+      req.onerror = () => reject(req.error)
+    })
+  }
+
+  private notifyUpdate(keyValue: T[K], updateType: DbUpdateType, oldItem?: T, newItem?: T): void {
+    this.listeners.forEach((listener) => listener(keyValue, updateType, oldItem, newItem))
+    if (this.broadcastChannel) {
+      this.broadcastChannel.postMessage({ keyValue, updateType, oldItem, newItem })
+    }
+  }
+
+  addListener(listener: DbUpdateListener<T, K>): () => void {
+    this.listeners.push(listener)
+    return () => this.removeListener(listener)
+  }
+
+  removeListener(listener: DbUpdateListener<T, K>): void {
+    this.listeners = this.listeners.filter((l) => l !== listener)
+  }
+
+  public async close(): Promise<void> {
+    if (this._db) {
+      this._db.close()
+      this._db = null
+    }
+    if (this.broadcastChannel) {
+      this.broadcastChannel.close()
+      this.broadcastChannel = undefined
+    }
+  }
+}

package/src/dbs/index.ts

@@ -0,0 +1,13 @@
+export type { AuthCommitment } from './auth-commitments.js'
+export { AuthCommitments } from './auth-commitments.js'
+
+export type { AuthKey } from './auth-keys.js'
+export { AuthKeys } from './auth-keys.js'
+
+export type { DbUpdateType, DbUpdateListener, Migration } from './generic.js'
+export { Generic } from './generic.js'
+export { Messages } from './messages.js'
+export { Signatures } from './signatures.js'
+export { Transactions } from './transactions.js'
+export { Wallets } from './wallets.js'
+export { Recovery } from './recovery.js'

package/src/dbs/messages.ts

@@ -0,0 +1,16 @@
+import { Message } from '../sequence/types/message-request.js'
+import { Generic } from './generic.js'
+
+const TABLE_NAME = 'messages'
+
+export class Messages extends Generic<Message, 'id'> {
+  constructor(dbName: string = 'sequence-messages') {
+    super(dbName, TABLE_NAME, 'id', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          db.createObjectStore(TABLE_NAME)
+        }
+      },
+    ])
+  }
+}

package/src/dbs/recovery.ts

@@ -0,0 +1,15 @@
+import { Generic } from './generic.js'
+import { QueuedRecoveryPayload } from '../sequence/types/recovery.js'
+
+const TABLE_NAME = 'queued-recovery-payloads'
+export class Recovery extends Generic<QueuedRecoveryPayload, 'id'> {
+  constructor(dbName: string = 'sequence-recovery') {
+    super(dbName, TABLE_NAME, 'id', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          db.createObjectStore(TABLE_NAME)
+        }
+      },
+    ])
+  }
+}

package/src/dbs/signatures.ts

@@ -0,0 +1,15 @@
+import { BaseSignatureRequest } from '../sequence/index.js'
+import { Generic } from './generic.js'
+
+const TABLE_NAME = 'envelopes'
+export class Signatures extends Generic<BaseSignatureRequest, 'id'> {
+  constructor(dbName: string = 'sequence-signature-requests') {
+    super(dbName, TABLE_NAME, 'id', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          db.createObjectStore(TABLE_NAME)
+        }
+      },
+    ])
+  }
+}

package/src/dbs/transactions.ts

@@ -0,0 +1,16 @@
+import { Transaction } from '../sequence/types/transaction-request.js'
+import { Generic } from './generic.js'
+
+const TABLE_NAME = 'transactions'
+
+export class Transactions extends Generic<Transaction, 'id'> {
+  constructor(dbName: string = 'sequence-transactions') {
+    super(dbName, TABLE_NAME, 'id', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          db.createObjectStore(TABLE_NAME)
+        }
+      },
+    ])
+  }
+}

package/src/dbs/wallets.ts

@@ -0,0 +1,16 @@
+import { Generic } from './generic.js'
+import { Wallet } from '../sequence/types/wallet.js'
+
+const TABLE_NAME = 'wallets'
+
+export class Wallets extends Generic<Wallet, 'address'> {
+  constructor(dbName: string = 'sequence-manager') {
+    super(dbName, TABLE_NAME, 'address', [
+      (db: IDBDatabase) => {
+        if (!db.objectStoreNames.contains(TABLE_NAME)) {
+          db.createObjectStore(TABLE_NAME)
+        }
+      },
+    ])
+  }
+}

package/src/identity/signer.ts

@@ -0,0 +1,78 @@
+import { Address, Signature, Hex, Bytes, PersonalMessage } from 'ox'
+import { Signers, State } from '@0xsequence/wallet-core'
+import { IdentityInstrument, KeyType } from '@0xsequence/identity-instrument'
+import { AuthKey } from '../dbs/auth-keys.js'
+import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives'
+import * as Identity from '@0xsequence/identity-instrument'
+
+export function toIdentityAuthKey(authKey: AuthKey): Identity.AuthKey {
+  return {
+    address: authKey.address,
+    keyType: Identity.KeyType.P256R1,
+    signer: authKey.identitySigner,
+    async sign(digest: Bytes.Bytes) {
+      const authKeySignature = await window.crypto.subtle.sign(
+        {
+          name: 'ECDSA',
+          hash: 'SHA-256',
+        },
+        authKey.privateKey,
+        digest,
+      )
+      return Hex.fromBytes(new Uint8Array(authKeySignature))
+    },
+  }
+}
+
+export class IdentitySigner implements Signers.Signer {
+  constructor(
+    readonly identityInstrument: IdentityInstrument,
+    readonly authKey: AuthKey,
+  ) {}
+
+  get address(): `0x${string}` {
+    if (!Address.validate(this.authKey.identitySigner)) {
+      throw new Error('No signer address found')
+    }
+    return Address.checksum(this.authKey.identitySigner)
+  }
+
+  async sign(
+    wallet: Address.Address,
+    chainId: bigint,
+    payload: Payload.Parented,
+  ): Promise<SequenceSignature.SignatureOfSignerLeaf> {
+    const payloadHash = Payload.hash(wallet, chainId, payload)
+    return this.signDigest(payloadHash)
+  }
+
+  async signDigest(digest: Bytes.Bytes): Promise<SequenceSignature.SignatureOfSignerLeafHash> {
+    const sigHex = await this.identityInstrument.sign(toIdentityAuthKey(this.authKey), digest)
+    const sig = Signature.fromHex(sigHex)
+    return {
+      type: 'hash',
+      ...sig,
+    }
+  }
+
+  async witness(stateWriter: State.Writer, wallet: Address.Address, extra?: Object): Promise<void> {
+    const payload = Payload.fromMessage(
+      Hex.fromString(
+        JSON.stringify({
+          action: 'consent-to-be-part-of-wallet',
+          wallet,
+          signer: this.address,
+          timestamp: Date.now(),
+          ...extra,
+        }),
+      ),
+    )
+
+    const signature = await this.sign(wallet, 0n, payload)
+    await stateWriter.saveWitnesses(wallet, 0n, payload, {
+      type: 'unrecovered-signer',
+      weight: 1n,
+      signature,
+    })
+  }
+}

package/src/index.ts

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

package/src/sequence/cron.ts

@@ -0,0 +1,134 @@
+import { Shared } from './manager.js'
+
+interface CronJob {
+  id: string
+  interval: number
+  lastRun: number
+  handler: () => Promise<void>
+}
+
+export class Cron {
+  private jobs: Map<string, CronJob> = new Map()
+  private checkInterval?: ReturnType<typeof setInterval>
+  private readonly STORAGE_KEY = 'sequence-cron-jobs'
+  private isStopping: boolean = false
+  private currentCheckJobsPromise: Promise<void> = Promise.resolve()
+
+  constructor(private readonly shared: Shared) {
+    this.start()
+  }
+
+  private start() {
+    if (this.isStopping) return
+    this.executeCheckJobsChain()
+    this.checkInterval = setInterval(() => this.executeCheckJobsChain(), 60 * 1000)
+  }
+
+  // Wraps checkJobs to chain executions and manage currentCheckJobsPromise
+  private executeCheckJobsChain(): void {
+    this.currentCheckJobsPromise = this.currentCheckJobsPromise
+      .catch(() => {}) // Ignore errors from previous chain link for sequencing
+      .then(() => {
+        if (!this.isStopping) {
+          return this.checkJobs()
+        }
+        return Promise.resolve()
+      })
+  }
+
+  public async stop(): Promise<void> {
+    this.isStopping = true
+
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval)
+      this.checkInterval = undefined
+      this.shared.modules.logger.log('Cron: Interval cleared.')
+    }
+
+    // Wait for the promise of the last (or current) checkJobs execution
+    await this.currentCheckJobsPromise.catch((err) => {
+      console.error('Cron: Error during currentCheckJobsPromise settlement in stop():', err)
+    })
+  }
+
+  registerJob(id: string, interval: number, handler: () => Promise<void>) {
+    if (this.jobs.has(id)) {
+      throw new Error(`Job with ID ${id} already exists`)
+    }
+    const job: CronJob = { id, interval, lastRun: 0, handler }
+    this.jobs.set(id, job)
+    // No syncWithStorage needed here, it happens in checkJobs
+  }
+
+  unregisterJob(id: string) {
+    this.jobs.delete(id)
+  }
+
+  private async checkJobs(): Promise<void> {
+    if (this.isStopping) {
+      return
+    }
+
+    try {
+      await navigator.locks.request('sequence-cron-jobs', async (lock: Lock | null) => {
+        if (this.isStopping) {
+          return
+        }
+        if (!lock) {
+          return
+        }
+
+        const now = Date.now()
+        const storage = await this.getStorageState()
+
+        for (const [id, job] of this.jobs) {
+          if (this.isStopping) {
+            break
+          }
+
+          const lastRun = storage.get(id)?.lastRun ?? job.lastRun
+          const timeSinceLastRun = now - lastRun
+
+          if (timeSinceLastRun >= job.interval) {
+            try {
+              await job.handler()
+              if (!this.isStopping) {
+                job.lastRun = now
+                storage.set(id, { lastRun: now })
+              } else {
+              }
+            } catch (error) {
+              if (error instanceof DOMException && error.name === 'AbortError') {
+                this.shared.modules.logger.log(`Cron: Job ${id} was aborted.`)
+              } else {
+                console.error(`Cron job ${id} failed:`, error)
+              }
+            }
+          }
+        }
+
+        if (!this.isStopping) {
+          await this.syncWithStorage()
+        }
+      })
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        this.shared.modules.logger.log('Cron: navigator.locks.request was aborted.')
+      } else {
+        console.error('Cron: Error in navigator.locks.request:', error)
+      }
+    }
+  }
+
+  private async getStorageState(): Promise<Map<string, { lastRun: number }>> {
+    if (this.isStopping) return new Map()
+    const state = localStorage.getItem(this.STORAGE_KEY)
+    return new Map(state ? JSON.parse(state) : [])
+  }
+
+  private async syncWithStorage() {
+    if (this.isStopping) return
+    const state = Array.from(this.jobs.entries()).map(([id, job]) => [id, { lastRun: job.lastRun }])
+    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state))
+  }
+}

package/src/sequence/devices.ts

@@ -0,0 +1,53 @@
+import { Signers } from '@0xsequence/wallet-core'
+import { Address } from 'ox'
+import { Kinds, WitnessExtraSignerKind } from './types/signer.js'
+import { Shared } from './manager.js'
+
+export class Devices {
+  constructor(private readonly shared: Shared) {}
+
+  async list() {
+    return this.shared.databases.encryptedPks.listAddresses()
+  }
+
+  async has(address: Address.Address) {
+    const entry = await this.shared.databases.encryptedPks.getEncryptedEntry(address)
+    return entry !== undefined
+  }
+
+  async create() {
+    const e = await this.shared.databases.encryptedPks.generateAndStore()
+    const s = await this.shared.databases.encryptedPks.getEncryptedPkStore(e.address)
+
+    if (!s) {
+      throw new Error('Failed to create session')
+    }
+
+    this.shared.modules.logger.log('Created new session:', s.address)
+    return new Signers.Pk.Pk(s)
+  }
+
+  async get(address: Address.Address) {
+    const s = await this.shared.databases.encryptedPks.getEncryptedPkStore(address)
+    if (!s) {
+      return undefined
+    }
+
+    return new Signers.Pk.Pk(s)
+  }
+
+  async witness(address: Address.Address, wallet: Address.Address) {
+    const signer = await this.get(address)
+    if (!signer) {
+      throw new Error('Signer not found')
+    }
+
+    await signer.witness(this.shared.sequence.stateProvider, wallet, {
+      signerKind: Kinds.LocalDevice,
+    } as WitnessExtraSignerKind)
+  }
+
+  async remove(address: Address.Address) {
+    await this.shared.databases.encryptedPks.remove(address)
+  }
+}