@0xsequence/wallet-core 0.0.0-20250520201059

package/src/state/local/memory.ts

@@ -0,0 +1,126 @@
+import { Context, Payload, Signature, Config, GenericTree } from '@0xsequence/wallet-primitives'
+import { Address, Hex } from 'ox'
+import { Store } from './index.js'
+
+export class MemoryStore implements Store {
+  private configs = new Map<`0x${string}`, Config.Config>()
+  private counterfactualWallets = new Map<`0x${string}`, { imageHash: Hex.Hex; context: Context.Context }>()
+  private payloads = new Map<`0x${string}`, { content: Payload.Parented; chainId: bigint; wallet: Address.Address }>()
+  private signerSubdigests = new Map<string, Set<string>>()
+  private signatures = new Map<`0x${string}`, Signature.SignatureOfSignerLeaf>()
+
+  private sapientSignerSubdigests = new Map<string, Set<string>>()
+  private sapientSignatures = new Map<`0x${string}`, Signature.SignatureOfSapientSignerLeaf>()
+
+  private trees = new Map<`0x${string}`, GenericTree.Tree>()
+
+  private getSignatureKey(signer: Address.Address, subdigest: Hex.Hex): string {
+    return `${signer.toLowerCase()}-${subdigest.toLowerCase()}`
+  }
+
+  private getSapientSignatureKey(signer: Address.Address, subdigest: Hex.Hex, imageHash: Hex.Hex): string {
+    return `${signer.toLowerCase()}-${imageHash.toLowerCase()}-${subdigest.toLowerCase()}`
+  }
+
+  async loadConfig(imageHash: Hex.Hex): Promise<Config.Config | undefined> {
+    return this.configs.get(imageHash.toLowerCase() as `0x${string}`)
+  }
+
+  async saveConfig(imageHash: Hex.Hex, config: Config.Config): Promise<void> {
+    this.configs.set(imageHash.toLowerCase() as `0x${string}`, config)
+  }
+
+  async loadCounterfactualWallet(
+    wallet: Address.Address,
+  ): Promise<{ imageHash: Hex.Hex; context: Context.Context } | undefined> {
+    return this.counterfactualWallets.get(wallet.toLowerCase() as `0x${string}`)
+  }
+
+  async saveCounterfactualWallet(wallet: Address.Address, imageHash: Hex.Hex, context: Context.Context): Promise<void> {
+    this.counterfactualWallets.set(wallet.toLowerCase() as `0x${string}`, { imageHash, context })
+  }
+
+  async loadPayloadOfSubdigest(
+    subdigest: Hex.Hex,
+  ): Promise<{ content: Payload.Parented; chainId: bigint; wallet: Address.Address } | undefined> {
+    return this.payloads.get(subdigest.toLowerCase() as `0x${string}`)
+  }
+
+  async savePayloadOfSubdigest(
+    subdigest: Hex.Hex,
+    payload: { content: Payload.Parented; chainId: bigint; wallet: Address.Address },
+  ): Promise<void> {
+    this.payloads.set(subdigest.toLowerCase() as `0x${string}`, payload)
+  }
+
+  async loadSubdigestsOfSigner(signer: Address.Address): Promise<Hex.Hex[]> {
+    const subdigests = this.signerSubdigests.get(signer.toLowerCase() as `0x${string}`)
+    return subdigests ? Array.from(subdigests).map((s) => s as Hex.Hex) : []
+  }
+
+  async loadSignatureOfSubdigest(
+    signer: Address.Address,
+    subdigest: Hex.Hex,
+  ): Promise<Signature.SignatureOfSignerLeaf | undefined> {
+    const key = this.getSignatureKey(signer, subdigest)
+    return this.signatures.get(key as `0x${string}`)
+  }
+
+  async saveSignatureOfSubdigest(
+    signer: Address.Address,
+    subdigest: Hex.Hex,
+    signature: Signature.SignatureOfSignerLeaf,
+  ): Promise<void> {
+    const key = this.getSignatureKey(signer, subdigest)
+    this.signatures.set(key as `0x${string}`, signature)
+
+    const signerKey = signer.toLowerCase()
+    const subdigestKey = subdigest.toLowerCase()
+
+    if (!this.signerSubdigests.has(signerKey)) {
+      this.signerSubdigests.set(signerKey, new Set())
+    }
+    this.signerSubdigests.get(signerKey)!.add(subdigestKey)
+  }
+
+  async loadSubdigestsOfSapientSigner(signer: Address.Address, imageHash: Hex.Hex): Promise<Hex.Hex[]> {
+    const key = `${signer.toLowerCase()}-${imageHash.toLowerCase()}`
+    const subdigests = this.sapientSignerSubdigests.get(key)
+    return subdigests ? Array.from(subdigests).map((s) => s as Hex.Hex) : []
+  }
+
+  async loadSapientSignatureOfSubdigest(
+    signer: Address.Address,
+    subdigest: Hex.Hex,
+    imageHash: Hex.Hex,
+  ): Promise<Signature.SignatureOfSapientSignerLeaf | undefined> {
+    const key = this.getSapientSignatureKey(signer, subdigest, imageHash)
+    return this.sapientSignatures.get(key as `0x${string}`)
+  }
+
+  async saveSapientSignatureOfSubdigest(
+    signer: Address.Address,
+    subdigest: Hex.Hex,
+    imageHash: Hex.Hex,
+    signature: Signature.SignatureOfSapientSignerLeaf,
+  ): Promise<void> {
+    const key = this.getSapientSignatureKey(signer, subdigest, imageHash)
+    this.sapientSignatures.set(key as `0x${string}`, signature)
+
+    const signerKey = `${signer.toLowerCase()}-${imageHash.toLowerCase()}`
+    const subdigestKey = subdigest.toLowerCase()
+
+    if (!this.sapientSignerSubdigests.has(signerKey)) {
+      this.sapientSignerSubdigests.set(signerKey, new Set())
+    }
+    this.sapientSignerSubdigests.get(signerKey)!.add(subdigestKey)
+  }
+
+  async loadTree(rootHash: Hex.Hex): Promise<GenericTree.Tree | undefined> {
+    return this.trees.get(rootHash.toLowerCase() as `0x${string}`)
+  }
+
+  async saveTree(rootHash: Hex.Hex, tree: GenericTree.Tree): Promise<void> {
+    this.trees.set(rootHash.toLowerCase() as `0x${string}`, tree)
+  }
+}

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

@@ -0,0 +1,253 @@
+import { Address, Hex } from 'ox'
+import { Config, Context, GenericTree, Payload, Signature, Utils } from '@0xsequence/wallet-primitives'
+import { Provider } from '../index.js'
+
+export class DevHttpProvider implements Provider {
+  private readonly baseUrl: string
+
+  constructor(baseUrl: string) {
+    // Remove trailing slash if present
+    this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
+  }
+
+  private async request<T>(method: 'GET' | 'POST', path: string, body?: any): Promise<T> {
+    const url = `${this.baseUrl}${path}`
+    const options: RequestInit = {
+      method,
+      headers: {},
+    }
+
+    if (body && method === 'POST') {
+      options.headers = { 'Content-Type': 'application/json' }
+      options.body = Utils.toJSON(body)
+    }
+
+    let response: Response
+    try {
+      response = await fetch(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)
+      throw networkError // Re-throw network errors
+    }
+
+    // --- Error Handling for HTTP Status ---
+    if (!response.ok) {
+      let errorPayload: any = { message: `HTTP error! Status: ${response.status}` }
+      try {
+        const errorText = await response.text()
+        const errorJson = await Utils.fromJSON(errorText)
+        errorPayload = { ...errorPayload, ...errorJson }
+      } catch (e) {
+        try {
+          // If JSON parsing fails, try getting text for better error message
+          const errorText = await response.text()
+          errorPayload.body = errorText
+        } catch (textErr) {
+          // Ignore if reading text also fails
+        }
+      }
+      console.error('HTTP Request Failed:', errorPayload)
+      throw new Error(errorPayload.message || `Request failed for ${method} ${path} with status ${response.status}`)
+    }
+
+    // --- Response Body Handling (with fix for empty body) ---
+    try {
+      // Handle cases where POST might return 201/204 No Content
+      // 204 should definitely have no body. 201 might or might not.
+      if (response.status === 204) {
+        return undefined as T // No content expected
+      }
+      if (response.status === 201 && method === 'POST') {
+        // Attempt to parse JSON (e.g., for { success: true }), but handle empty body gracefully
+        const text = await response.clone().text() // Clone and check text first
+        if (text.trim() === '') {
+          return undefined as T // Treat empty 201 as success with no specific return data
+        }
+        // If not empty, try parsing JSON
+        const responseText = await response.text()
+        return (await Utils.fromJSON(responseText)) as T
+      }
+
+      // For 200 OK or other success statuses expecting a body
+      // Clone the response before attempting to read the body,
+      // so we can potentially read it again (as text) if json() fails.
+      const clonedResponse = response.clone()
+      const textContent = await clonedResponse.text() // Read as text first
+
+      if (textContent.trim() === '') {
+        // If the body is empty (or only whitespace) and status was OK (checked above),
+        // treat this as the server sending 'undefined' or 'null'.
+        // Return `undefined` to match the expected optional types in the Provider interface.
+        return undefined as T
+      } else {
+        // If there is content, attempt to parse it as JSON.
+        // We use the original response here, which hasn't had its body consumed yet.
+        const responseText = await response.text()
+        const data = await Utils.fromJSON(responseText)
+
+        // BigInt Deserialization note remains the same: manual conversion may be needed by consumer.
+        return data as T
+      }
+    } catch (error) {
+      // This catch block now primarily handles errors from response.json()
+      // if the non-empty textContent wasn't valid JSON.
+      console.error(`Error processing response body for ${method} ${url}:`, error)
+      // Also include the raw text in the error if possible
+      try {
+        const text = await response.text() // Try reading original response if not already done
+        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) {
+        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)}`,
+        )
+      }
+    }
+  }
+
+  // --- Reader Methods ---
+
+  async getConfiguration(imageHash: Hex.Hex): Promise<Config.Config | undefined> {
+    // The response needs careful handling if BigInts are involved (threshold, checkpoint)
+    const config = await this.request<Config.Config | undefined>('GET', `/configuration/${imageHash}`)
+    // Manual conversion example (if needed by consumer):
+    // if (config?.threshold) config.threshold = BigInt(config.threshold);
+    // if (config?.checkpoint) config.checkpoint = BigInt(config.checkpoint);
+    return config
+  }
+
+  async getDeploy(wallet: Address.Address): Promise<{ imageHash: Hex.Hex; context: Context.Context } | undefined> {
+    return this.request('GET', `/deploy/${wallet}`)
+  }
+
+  async getWallets(signer: Address.Address): Promise<{
+    [wallet: Address.Address]: {
+      chainId: bigint
+      payload: Payload.Parented
+      signature: Signature.SignatureOfSignerLeaf
+    }
+  }> {
+    // Response `chainId` will be a string/number, needs conversion if BigInt is strictly required upstream
+    return this.request('GET', `/wallets/signer/${signer}`)
+  }
+
+  async getWalletsForSapient(
+    signer: Address.Address,
+    imageHash: Hex.Hex,
+  ): Promise<{
+    [wallet: Address.Address]: {
+      chainId: bigint
+      payload: Payload.Parented
+      signature: Signature.SignatureOfSapientSignerLeaf
+    }
+  }> {
+    // Response `chainId` will be a string/number, needs conversion
+    return this.request('GET', `/wallets/sapient/${signer}/${imageHash}`)
+  }
+
+  async getWitnessFor(
+    wallet: Address.Address,
+    signer: Address.Address,
+  ): Promise<
+    | {
+        chainId: bigint
+        payload: Payload.Parented
+        signature: Signature.SignatureOfSignerLeaf
+      }
+    | undefined
+  > {
+    // Response `chainId` will be a string/number, needs conversion
+    return this.request('GET', `/witness/${wallet}/signer/${signer}`)
+  }
+
+  async getWitnessForSapient(
+    wallet: Address.Address,
+    signer: Address.Address,
+    imageHash: Hex.Hex,
+  ): Promise<
+    | {
+        chainId: bigint
+        payload: Payload.Parented
+        signature: Signature.SignatureOfSapientSignerLeaf
+      }
+    | undefined
+  > {
+    // Response `chainId` will be a string/number, needs conversion
+    return this.request('GET', `/witness/sapient/${wallet}/${signer}/${imageHash}`)
+  }
+
+  async getConfigurationUpdates(
+    wallet: Address.Address,
+    fromImageHash: Hex.Hex,
+    options?: { allUpdates?: boolean },
+  ): Promise<Array<{ imageHash: Hex.Hex; signature: Signature.RawSignature }>> {
+    const query = options?.allUpdates ? '?allUpdates=true' : ''
+    // Response signature object might contain BigInts (threshold, checkpoint) as strings
+    return this.request('GET', `/configuration-updates/${wallet}/from/${fromImageHash}${query}`)
+  }
+
+  async getTree(rootHash: Hex.Hex): Promise<GenericTree.Tree | undefined> {
+    return this.request('GET', `/tree/${rootHash}`)
+  }
+
+  // --- Writer Methods ---
+
+  async saveWallet(deployConfiguration: Config.Config, context: Context.Context): Promise<void> {
+    await this.request<void>('POST', '/wallet', { deployConfiguration, context })
+  }
+
+  async saveWitnesses(
+    wallet: Address.Address,
+    chainId: bigint,
+    payload: Payload.Parented,
+    signatures: Signature.RawTopology,
+  ): Promise<void> {
+    // chainId will be correctly stringified by the jsonReplacer
+    await this.request<void>('POST', '/witnesses', { wallet, chainId, payload, signatures })
+  }
+
+  async saveUpdate(
+    wallet: Address.Address,
+    configuration: Config.Config,
+    signature: Signature.RawSignature,
+  ): Promise<void> {
+    // configuration and signature might contain BigInts, handled by replacer
+    await this.request<void>('POST', '/update', { wallet, configuration, signature })
+  }
+
+  async saveTree(tree: GenericTree.Tree): Promise<void> {
+    await this.request<void>('POST', '/tree', { tree })
+  }
+
+  saveConfiguration(config: Config.Config): Promise<void> {
+    return this.request<void>('POST', '/configuration', { config })
+  }
+
+  saveDeploy(imageHash: Hex.Hex, context: Context.Context): Promise<void> {
+    return this.request<void>('POST', '/deploy', { imageHash, context })
+  }
+
+  async getPayload(opHash: Hex.Hex): Promise<
+    | {
+        chainId: bigint
+        payload: Payload.Parented
+        wallet: Address.Address
+      }
+    | undefined
+  > {
+    return this.request<
+      | {
+          chainId: bigint
+          payload: Payload.Parented
+          wallet: Address.Address
+        }
+      | undefined
+    >('GET', `/payload/${opHash}`)
+  }
+
+  async savePayload(wallet: Address.Address, payload: Payload.Parented, chainId: bigint): Promise<void> {
+    return this.request<void>('POST', '/payload', { wallet, payload, chainId })
+  }
+}

package/src/state/remote/index.ts

@@ -0,0 +1 @@
+export * from './dev-http.js'

package/src/state/utils.ts

@@ -0,0 +1,50 @@
+import { Payload, Signature } from '@0xsequence/wallet-primitives'
+import { Address, Hex } from 'ox'
+import { Reader } from './index.js'
+import { isSapientSigner, SapientSigner, Signer } from '../signers/index.js'
+
+export type WalletWithWitness<S extends Signer | SapientSigner> = {
+  wallet: Address.Address
+  chainId: bigint
+  payload: Payload.Parented
+  signature: S extends SapientSigner ? Signature.SignatureOfSapientSignerLeaf : Signature.SignatureOfSignerLeaf
+}
+
+export async function getWalletsFor<S extends Signer | SapientSigner>(
+  stateReader: Reader,
+  signer: S,
+): Promise<Array<WalletWithWitness<S>>> {
+  const wallets = await retrieveWallets(stateReader, signer)
+  return Object.entries(wallets).map(([wallet, { chainId, payload, signature }]) => {
+    Hex.assert(wallet)
+    return {
+      wallet,
+      chainId,
+      payload,
+      signature,
+    }
+  })
+}
+
+async function retrieveWallets<S extends Signer | SapientSigner>(
+  stateReader: Reader,
+  signer: S,
+): Promise<{
+  [wallet: `0x${string}`]: {
+    chainId: bigint
+    payload: Payload.Parented
+    signature: S extends SapientSigner ? Signature.SignatureOfSapientSignerLeaf : Signature.SignatureOfSignerLeaf
+  }
+}> {
+  if (isSapientSigner(signer)) {
+    const [signerAddress, signerImageHash] = await Promise.all([signer.address, signer.imageHash])
+    if (signerImageHash) {
+      return stateReader.getWalletsForSapient(signerAddress, signerImageHash) as unknown as any
+    } else {
+      console.warn('Sapient signer has no imageHash')
+      return {} as any
+    }
+  } else {
+    return stateReader.getWallets(await signer.address) as unknown as any
+  }
+}