ethagent 3.0.2 → 3.1.0

package/src/identity/hub/profile/effects.ts

@@ -6,21 +6,15 @@ import {
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
-  prepareSyncedSkillsTree,
   prepareSyncedPublicSkillsJson,
-  readContinuityFiles,
   writePublicSkillsFile,
 } from '../../continuity/storage.js'
 import {
-  appendPublicSkillEntries,
   createAgentCard,
   defaultPublicSkillsProfile,
   serializeAgentCard,
 } from '../../continuity/publicSkills.js'
-import {
-  derivePublicSkillEntries,
-  syncPublicSkillsManifest,
-} from '../../continuity/skills/publicSkillsSync.js'
+import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
 import {
@@ -30,10 +24,7 @@ import {
   withEthagentPointers,
   type Erc8004RegistryConfig,
 } from '../../registry/erc8004.js'
-import {
-  VAULT_ABI,
-  encodeRotateAgentURI,
-} from '../../registry/vault.js'
+import { encodeRotateAgentURI } from '../../registry/vault.js'
 import { resolveValidatedPinataJwt, savePinataJwt } from '../../storage/pinataJwt.js'
 import {
   openBrowserWalletSession,
@@ -67,8 +58,11 @@ import {
   walletRestoreAccessContext,
 } from '../continuity/snapshot.js'
 import { rebackupCompletionMessage } from '../continuity/effects.js'
+import {
+  assertVaultSignerCanRotateAgentUri,
+  prepareOperatorProfileArtifacts,
+} from './operatorSave.js'
 
-type BackupMetadata = NonNullable<EthagentIdentity['backup']>
 type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
 
 type PublicProfilePreparedTransaction = {
@@ -369,164 +363,6 @@ async function runOperatorWalletVaultPublicProfileSave(args: {
   }
 }
 
-type OperatorProfileArtifacts = {
-  nextIdentity: EthagentIdentity
-  publicSkillsJson: string
-  agentUri: string
-  metadataCid: string
-}
-
-async function prepareOperatorProfileArtifacts(args: {
-  step: Extract<Step, { kind: 'public-profile-signing' }>
-  wallet: BrowserWalletSignature
-  snapshotOwner: Address
-  walletAccess: WalletAccessContext
-  challengePurpose: WalletChallengePurpose
-}): Promise<OperatorProfileArtifacts> {
-  const { step, wallet, snapshotOwner, walletAccess, challengePurpose } = args
-  const {
-    state,
-    nextName,
-    nextDescription,
-    nextEnsName,
-    uploadedImageUri,
-  } = await prepareProfileStateForSave({
-    identity: step.identity,
-    registry: step.registry,
-    profileUpdates: step.profileUpdates,
-    pinataJwt: step.pinataJwt,
-    ownerAddress: snapshotOwner,
-    walletAccount: getAddress(wallet.account),
-    includeLastBackedUpAt: true,
-  })
-  const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
-
-  const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
-  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(publicSkillsPin)
-  const publicSkillEntries = await derivePublicSkillEntries(nextIdentityForFiles)
-  const augmentedPublicProfile = appendPublicSkillEntries(
-    defaultPublicSkillsProfile(nextIdentityForFiles),
-    publicSkillEntries,
-  )
-  const agentCardPin = await addToIpfs(
-    DEFAULT_IPFS_API_URL,
-    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
-    fetch,
-    { pinataJwt: step.pinataJwt },
-  )
-  assertVerifiedPin(agentCardPin)
-
-  const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
-  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
-  const envelope = createContinuityEnvelopeForSave({
-    identity: nextIdentityForFiles,
-    registry: step.registry,
-    ownerAddress: snapshotOwner,
-    signerAddress: wallet.account,
-    walletSignature: wallet.signature,
-    state,
-    files: continuityFiles,
-    skills: skillsTree,
-    walletAccess,
-    challengePurpose,
-  })
-  const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(statePin)
-
-  const publicSkills: PublicSkillsMetadata = {
-    cid: publicSkillsPin.cid,
-    agentCardCid: agentCardPin.cid,
-    updatedAt: envelope.createdAt,
-    status: 'pinned',
-  }
-  const backup: BackupMetadata = {
-    cid: statePin.cid,
-    createdAt: envelope.createdAt,
-    envelopeVersion: envelope.envelopeVersion,
-    ipfsApiUrl: DEFAULT_IPFS_API_URL,
-    status: 'pinned',
-    ownerAddress: snapshotOwner,
-    chainId: step.registry.chainId,
-    rpcUrl: step.registry.rpcUrl,
-    identityRegistryAddress: step.registry.identityRegistryAddress,
-    agentId: step.identity.agentId!,
-  }
-
-  const registration = withEthagentPointers({
-    type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
-    name: nextName ?? deriveAgentName(step.identity),
-    ...(nextDescription ? { description: nextDescription } : {}),
-    ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
-  }, {
-    backup: { cid: statePin.cid, envelopeVersion: envelope.envelopeVersion, createdAt: envelope.createdAt },
-    publicDiscovery: { skillsCid: publicSkills.cid, agentCardCid: publicSkills.agentCardCid, updatedAt: publicSkills.updatedAt },
-    registration: { chainId: step.registry.chainId, identityRegistryAddress: step.registry.identityRegistryAddress, agentId: step.identity.agentId },
-    ensName: nextEnsName,
-    operators: operatorsPointerFromState(state, nextEnsName),
-    ownerAddress: snapshotOwner,
-  })
-  const metadataPin = await addToIpfs(DEFAULT_IPFS_API_URL, JSON.stringify(registration, null, 2), fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(metadataPin)
-  const metadataCid = metadataPin.cid
-  const agentUri = `ipfs://${metadataCid}`
-
-  const nextIdentity: EthagentIdentity = {
-    ...step.identity,
-    state,
-    backup: { ...backup, metadataCid, agentUri },
-    publicSkills,
-    agentUri,
-    metadataCid,
-  }
-
-  return {
-    nextIdentity,
-    publicSkillsJson,
-    agentUri,
-    metadataCid,
-  }
-}
-
-async function assertVaultSignerCanRotateAgentUri(args: {
-  registry: Erc8004RegistryConfig
-  vaultAddress: Address
-  agentId: bigint
-  signer: Address
-}): Promise<void> {
-  const client = createErc8004PublicClient(args.registry)
-  const registryAddress = getAddress(args.registry.identityRegistryAddress)
-  const vaultAddress = getAddress(args.vaultAddress)
-  const signer = getAddress(args.signer)
-  let vaultOwner: Address
-  try {
-    vaultOwner = getAddress(await client.readContract({
-      address: vaultAddress,
-      abi: VAULT_ABI,
-      functionName: 'agentOwner',
-      args: [registryAddress, args.agentId],
-    }) as Address)
-  } catch (err: unknown) {
-    throw new Error(`Could not verify Vault custody for agent #${args.agentId.toString()}: ${err instanceof Error ? err.message : String(err)}`)
-  }
-  if (vaultOwner === '0x0000000000000000000000000000000000000000') {
-    throw new Error(`Vault ${vaultAddress} does not currently hold agent token #${args.agentId.toString()}. Connect the owner wallet and run "Fix Records" or return the token to the vault before retrying.`)
-  }
-  if (vaultOwner.toLowerCase() === signer.toLowerCase()) return
-
-  const isOperator = await client.readContract({
-    address: vaultAddress,
-    abi: VAULT_ABI,
-    functionName: 'metadataOperators',
-    args: [registryAddress, args.agentId, signer],
-  }) as boolean
-  if (isOperator) return
-
-  throw new Error(
-    `Operator wallet ${signer} is not yet authorized on the Vault to rotate this agent's URI. Connect the owner wallet and run "Fix Records" or re-add this operator to grant the permission.`,
-  )
-}
-
 export async function runPublicProfileStorageSubmit(
   input: string,
   step: Extract<Step, { kind: 'public-profile-storage' }>,

package/src/identity/hub/profile/operatorSave.ts

@@ -0,0 +1,202 @@
+import { getAddress, type Address } from 'viem'
+import type { EthagentIdentity } from '../../../storage/config.js'
+import {
+  createWalletRestoreAccessChallenge,
+  serializeContinuitySnapshotEnvelope,
+  type WalletChallengePurpose,
+} from '../../continuity/envelope.js'
+import {
+  prepareSyncedSkillsTree,
+  readContinuityFiles,
+} from '../../continuity/storage.js'
+import {
+  appendPublicSkillEntries,
+  createAgentCard,
+  defaultPublicSkillsProfile,
+  serializeAgentCard,
+} from '../../continuity/publicSkills.js'
+import {
+  derivePublicSkillEntries,
+  syncPublicSkillsManifest,
+} from '../../continuity/skills/publicSkillsSync.js'
+import { addToIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
+import {
+  createErc8004PublicClient,
+  withEthagentPointers,
+  type Erc8004RegistryConfig,
+} from '../../registry/erc8004.js'
+import { VAULT_ABI } from '../../registry/vault.js'
+import type { BrowserWalletSignature } from '../../wallet/browserWallet.js'
+import type { Step } from '../identityHubReducer.js'
+import {
+  assertVerifiedPin,
+  deriveAgentName,
+  prepareProfileStateForSave,
+} from '../shared/effects/profilePrep.js'
+import {
+  createContinuityEnvelopeForSave,
+  operatorsPointerFromState,
+  walletRestoreAccessContext,
+} from '../continuity/snapshot.js'
+
+type BackupMetadata = NonNullable<EthagentIdentity['backup']>
+type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type WalletAccessContext = NonNullable<ReturnType<typeof walletRestoreAccessContext>>
+
+export type OperatorProfileArtifacts = {
+  nextIdentity: EthagentIdentity
+  publicSkillsJson: string
+  agentUri: string
+  metadataCid: string
+}
+
+export async function prepareOperatorProfileArtifacts(args: {
+  step: Extract<Step, { kind: 'public-profile-signing' }>
+  wallet: BrowserWalletSignature
+  snapshotOwner: Address
+  walletAccess: WalletAccessContext
+  challengePurpose: WalletChallengePurpose
+}): Promise<OperatorProfileArtifacts> {
+  const { step, wallet, snapshotOwner, walletAccess, challengePurpose } = args
+  const {
+    state,
+    nextName,
+    nextDescription,
+    nextEnsName,
+    uploadedImageUri,
+  } = await prepareProfileStateForSave({
+    identity: step.identity,
+    registry: step.registry,
+    profileUpdates: step.profileUpdates,
+    pinataJwt: step.pinataJwt,
+    ownerAddress: snapshotOwner,
+    walletAccount: getAddress(wallet.account),
+    includeLastBackedUpAt: true,
+  })
+  const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
+
+  const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
+  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
+  assertVerifiedPin(publicSkillsPin)
+  const publicSkillEntries = await derivePublicSkillEntries(nextIdentityForFiles)
+  const augmentedPublicProfile = appendPublicSkillEntries(
+    defaultPublicSkillsProfile(nextIdentityForFiles),
+    publicSkillEntries,
+  )
+  const agentCardPin = await addToIpfs(
+    DEFAULT_IPFS_API_URL,
+    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
+    fetch,
+    { pinataJwt: step.pinataJwt },
+  )
+  assertVerifiedPin(agentCardPin)
+
+  const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
+  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
+  const envelope = createContinuityEnvelopeForSave({
+    identity: nextIdentityForFiles,
+    registry: step.registry,
+    ownerAddress: snapshotOwner,
+    signerAddress: wallet.account,
+    walletSignature: wallet.signature,
+    state,
+    files: continuityFiles,
+    skills: skillsTree,
+    walletAccess,
+    challengePurpose,
+  })
+  const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
+  assertVerifiedPin(statePin)
+
+  const publicSkills: PublicSkillsMetadata = {
+    cid: publicSkillsPin.cid,
+    agentCardCid: agentCardPin.cid,
+    updatedAt: envelope.createdAt,
+    status: 'pinned',
+  }
+  const backup: BackupMetadata = {
+    cid: statePin.cid,
+    createdAt: envelope.createdAt,
+    envelopeVersion: envelope.envelopeVersion,
+    ipfsApiUrl: DEFAULT_IPFS_API_URL,
+    status: 'pinned',
+    ownerAddress: snapshotOwner,
+    chainId: step.registry.chainId,
+    rpcUrl: step.registry.rpcUrl,
+    identityRegistryAddress: step.registry.identityRegistryAddress,
+    agentId: step.identity.agentId!,
+  }
+
+  const registration = withEthagentPointers({
+    type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
+    name: nextName ?? deriveAgentName(step.identity),
+    ...(nextDescription ? { description: nextDescription } : {}),
+    ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
+  }, {
+    backup: { cid: statePin.cid, envelopeVersion: envelope.envelopeVersion, createdAt: envelope.createdAt },
+    publicDiscovery: { skillsCid: publicSkills.cid, agentCardCid: publicSkills.agentCardCid, updatedAt: publicSkills.updatedAt },
+    registration: { chainId: step.registry.chainId, identityRegistryAddress: step.registry.identityRegistryAddress, agentId: step.identity.agentId },
+    ensName: nextEnsName,
+    operators: operatorsPointerFromState(state, nextEnsName),
+    ownerAddress: snapshotOwner,
+  })
+  const metadataPin = await addToIpfs(DEFAULT_IPFS_API_URL, JSON.stringify(registration, null, 2), fetch, { pinataJwt: step.pinataJwt })
+  assertVerifiedPin(metadataPin)
+  const metadataCid = metadataPin.cid
+  const agentUri = `ipfs://${metadataCid}`
+
+  const nextIdentity: EthagentIdentity = {
+    ...step.identity,
+    state,
+    backup: { ...backup, metadataCid, agentUri },
+    publicSkills,
+    agentUri,
+    metadataCid,
+  }
+
+  return {
+    nextIdentity,
+    publicSkillsJson,
+    agentUri,
+    metadataCid,
+  }
+}
+
+export async function assertVaultSignerCanRotateAgentUri(args: {
+  registry: Erc8004RegistryConfig
+  vaultAddress: Address
+  agentId: bigint
+  signer: Address
+}): Promise<void> {
+  const client = createErc8004PublicClient(args.registry)
+  const registryAddress = getAddress(args.registry.identityRegistryAddress)
+  const vaultAddress = getAddress(args.vaultAddress)
+  const signer = getAddress(args.signer)
+  let vaultOwner: Address
+  try {
+    vaultOwner = getAddress(await client.readContract({
+      address: vaultAddress,
+      abi: VAULT_ABI,
+      functionName: 'agentOwner',
+      args: [registryAddress, args.agentId],
+    }) as Address)
+  } catch (err: unknown) {
+    throw new Error(`Could not verify Vault custody for agent #${args.agentId.toString()}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+  if (vaultOwner === '0x0000000000000000000000000000000000000000') {
+    throw new Error(`Vault ${vaultAddress} does not currently hold agent token #${args.agentId.toString()}. Connect the owner wallet and run "Fix Records" or return the token to the vault before retrying.`)
+  }
+  if (vaultOwner.toLowerCase() === signer.toLowerCase()) return
+
+  const isOperator = await client.readContract({
+    address: vaultAddress,
+    abi: VAULT_ABI,
+    functionName: 'metadataOperators',
+    args: [registryAddress, args.agentId, signer],
+  }) as boolean
+  if (isOperator) return
+
+  throw new Error(
+    `Operator wallet ${signer} is not yet authorized on the Vault to rotate this agent's URI. Connect the owner wallet and run "Fix Records" or re-add this operator to grant the permission.`,
+  )
+}

package/src/identity/wallet/browserWallet/html.ts

@@ -1,26 +1,7 @@
-import { readFileSync, statSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { transformSync } from 'esbuild'
 import { normalizeWalletPayloadPurpose } from '../walletPurposeCompat.js'
+import { loadWalletPageSource } from './walletPageSource.js'
 
-const WALLET_PAGE_FILE = join(dirname(fileURLToPath(import.meta.url)), '..', 'page.tsx')
-const WALLET_PAGE_MODULE_FILES = [
-  join('page', 'types.ts'),
-  join('page', 'html.ts'),
-  join('page', 'constants.ts'),
-  join('page', 'styles', 'base.ts'),
-  join('page', 'styles', 'components.ts'),
-  join('page', 'styles', 'responsive.ts'),
-  join('page', 'styles', 'index.ts'),
-  join('page', 'markup.ts'),
-  join('page', 'grainient.ts'),
-  join('page', 'state.ts'),
-  join('page', 'copy.ts'),
-  join('page', 'walletProvider.ts'),
-  join('page', 'view.ts'),
-  join('page', 'controller.ts'),
-] as const
 const WALLET_HTML = loadWalletHtml()
 
 export function walletPage(title: string, sessionToken: string, payload: Record<string, unknown>): string {
@@ -43,43 +24,6 @@ function loadWalletHtml(): string {
   return wrapInWalletShell(compiled)
 }
 
-function loadWalletPageSource(): string {
-  const pageFile = locateWalletPageFile()
-  const pageDir = dirname(pageFile)
-  const files = [
-    ...WALLET_PAGE_MODULE_FILES.map(file => join(pageDir, file)),
-    pageFile,
-  ]
-  return stripWalletModuleSyntax(files.map(file => readFileSync(file, 'utf8')).join('\n'))
-}
-
-function stripWalletModuleSyntax(source: string): string {
-  const out: string[] = []
-  let skippingImport = false
-  for (const line of source.split(/\r?\n/)) {
-    const trimmed = line.trim()
-    if (skippingImport) {
-      if (/\bfrom\s+['"][^'"]+['"]/.test(trimmed) || trimmed.endsWith(';')) skippingImport = false
-      continue
-    }
-    if (trimmed.startsWith('import ')) {
-      if (!/\bfrom\s+['"][^'"]+['"]/.test(trimmed) && !trimmed.endsWith(';')) skippingImport = true
-      continue
-    }
-    out.push(line.replace(/^export\s+(?=(async\s+function|const|let|function|interface|type|class)\b)/, ''))
-  }
-  return out.join('\n')
-}
-
-function locateWalletPageFile(): string {
-  try {
-    statSync(WALLET_PAGE_FILE)
-    return WALLET_PAGE_FILE
-  } catch {
-    return join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..', '..', 'src', 'identity', 'wallet', 'page.tsx')
-  }
-}
-
 function wrapInWalletShell(compiledJs: string): string {
   const safeJs = compiledJs.replaceAll('</', '<\\/')
   return `<!doctype html>

package/src/identity/wallet/browserWallet/walletPageSource.ts

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const WALLET_PAGE_ENTRY_FILE = 'page.tsx'
+const WALLET_PAGE_MODULE_FILES = [
+  join('page', 'types.ts'),
+  join('page', 'html.ts'),
+  join('page', 'constants.ts'),
+  join('page', 'styles', 'base.ts'),
+  join('page', 'styles', 'components.ts'),
+  join('page', 'styles', 'responsive.ts'),
+  join('page', 'styles', 'index.ts'),
+  join('page', 'markup.ts'),
+  join('page', 'grainient.ts'),
+  join('page', 'state.ts'),
+  join('page', 'copy.ts'),
+  join('page', 'errorView.ts'),
+  join('page', 'walletProvider.ts'),
+  join('page', 'view.ts'),
+  join('page', 'controller.ts'),
+] as const
+
+export function walletPageSourceFiles(fromUrl = import.meta.url): string[] {
+  const sourceRoot = locateWalletPageSourceRoot(fromUrl)
+  return [
+    ...WALLET_PAGE_MODULE_FILES.map(file => join(sourceRoot, file)),
+    join(sourceRoot, WALLET_PAGE_ENTRY_FILE),
+  ]
+}
+
+export function walletPageSourceFile(relativeFile: string, fromUrl = import.meta.url): string {
+  return join(locateWalletPageSourceRoot(fromUrl), relativeFile)
+}
+
+export function loadWalletPageRawSource(fromUrl = import.meta.url): string {
+  return walletPageSourceFiles(fromUrl).map(file => readFileSync(file, 'utf8')).join('\n')
+}
+
+export function loadWalletPageSource(fromUrl = import.meta.url): string {
+  return stripWalletModuleSyntax(loadWalletPageRawSource(fromUrl))
+}
+
+export function stripWalletModuleSyntax(source: string): string {
+  const out: string[] = []
+  let skippingImport = false
+  for (const line of source.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (skippingImport) {
+      if (/\bfrom\s+['"][^'"]+['"]/.test(trimmed) || trimmed.endsWith(';')) skippingImport = false
+      continue
+    }
+    if (trimmed.startsWith('import ')) {
+      if (!/\bfrom\s+['"][^'"]+['"]/.test(trimmed) && !trimmed.endsWith(';')) skippingImport = true
+      continue
+    }
+    out.push(line.replace(/^export\s+(?=(async\s+function|const|let|function|interface|type|class)\b)/, ''))
+  }
+  return out.join('\n')
+}
+
+function locateWalletPageSourceRoot(fromUrl: string): string {
+  for (const candidate of walletPageSourceRootCandidates(fromUrl)) {
+    if (hasWalletPageSourceFiles(candidate)) return candidate
+  }
+  throw new Error('could not locate browser wallet page source files')
+}
+
+function walletPageSourceRootCandidates(fromUrl: string): string[] {
+  const start = dirname(fileURLToPath(fromUrl))
+  const candidates = [join(start, '..')]
+  for (let dir = start; ; dir = dirname(dir)) {
+    candidates.push(join(dir, 'src', 'identity', 'wallet'))
+    const parent = dirname(dir)
+    if (parent === dir) break
+  }
+  return Array.from(new Set(candidates))
+}
+
+function hasWalletPageSourceFiles(sourceRoot: string): boolean {
+  return [
+    ...WALLET_PAGE_MODULE_FILES,
+    WALLET_PAGE_ENTRY_FILE,
+  ].every(file => existsSync(join(sourceRoot, file)))
+}

package/src/identity/wallet/page/controller.ts

@@ -11,12 +11,12 @@ import {
   errorSlot,
   getLastWalletError,
   initializeViewElements,
-  serializeWalletError,
   setState,
   showPreparedMessage,
   statusHint,
   statusText,
 } from './view.js'
+import { serializeWalletError } from './errorView.js'
 import {
   buildTxParams,
   clearCurrentWalletMethod,