ethagent 1.1.2 → 2.0.1

package/src/identity/hub/utils.ts

@@ -0,0 +1,79 @@
+import type { EthagentConfig, EthagentIdentity } from '../../storage/config.js'
+import { supportedErc8004ChainForId } from '../registry/erc8004.js'
+import { snapshotSaveRequiresOwnerSigner } from './effects/shared/snapshot.js'
+import type { IdentityHubInitialAction } from './types.js'
+import type { ProfileUpdates, Step } from './identityHubReducer.js'
+
+const MIN_BUSY_ERROR_MS = 2000
+
+export function isWalletCancelled(err: unknown): boolean {
+  if (!err) return false
+  const message = err instanceof Error ? err.message : String(err)
+  return /wallet request was cancelled/i.test(message)
+    || /user rejected/i.test(message)
+}
+
+export function isStorageError(err: unknown): boolean {
+  const message = err instanceof Error ? err.message : String(err)
+  return /pinata|ipfs|pin|storage/i.test(message)
+}
+
+export function chainLabel(chainId: number): string {
+  return supportedErc8004ChainForId(chainId)?.name ?? `chain ${chainId}`
+}
+
+export function waitForMinimumBusyTime(startedAt: number): Promise<void> {
+  const remaining = MIN_BUSY_ERROR_MS - (Date.now() - startedAt)
+  return remaining > 0
+    ? new Promise(resolve => setTimeout(resolve, remaining))
+    : Promise.resolve()
+}
+
+export function capitalizeFeedbackMessage(message: string): string {
+  return message.replace(/^(\s*)([a-z])/, (_match, leading: string, first: string) => `${leading}${first.toUpperCase()}`)
+}
+
+export function rebackupWalletApprovalView(
+  identity: EthagentIdentity,
+  profileUpdates?: ProfileUpdates,
+): { title: string; subtitle: string; label: string } {
+  if (snapshotSaveRequiresOwnerSigner(identity, profileUpdates)) {
+    return {
+      title: 'Use Owner Wallet',
+      subtitle: 'Owner wallet signs this custody-controlled identity update.',
+      label: 'waiting for owner wallet signature...',
+    }
+  }
+  return {
+    title: 'Use Wallet',
+    subtitle: 'Owner or operator wallet signs the encrypted snapshot and token URI update.',
+    label: 'waiting for wallet signature...',
+  }
+}
+
+export function isCreateStep(step: Step): step is Extract<Step, { kind: 'replace-confirm' | 'create-name' | 'create-description' | 'create-custody' | 'create-preflight' | 'create-registry' | 'create-signing' | 'create-storage' }> {
+  return step.kind === 'replace-confirm'
+    || step.kind === 'create-name'
+    || step.kind === 'create-description'
+    || step.kind === 'create-custody'
+    || step.kind === 'create-preflight'
+    || step.kind === 'create-registry'
+    || step.kind === 'create-signing'
+    || step.kind === 'create-storage'
+}
+
+export function isRestoreStep(step: Step): step is Exclude<Extract<Step, { kind: `restore-${string}` }>, { kind: 'restore-wallet' | 'restore-network' }> {
+  return step.kind.startsWith('restore-') && step.kind !== 'restore-wallet' && step.kind !== 'restore-network'
+}
+
+export function initialStepForAction(
+  action: IdentityHubInitialAction | undefined,
+  config: EthagentConfig | undefined,
+): Step {
+  if (action === 'create') return config?.identity ? { kind: 'replace-confirm', next: 'create' } : { kind: 'create-name' }
+  if (action === 'load') return { kind: 'restore-wallet', purpose: config?.identity ? 'switch' : 'restore' }
+  if (action === 'save-snapshot') return config?.identity ? { kind: 'rebackup-start', back: { kind: 'menu' } } : { kind: 'menu' }
+  if (action === 'save-prompt') return config?.identity ? { kind: 'save-prompt', back: { kind: 'menu' } } : { kind: 'menu' }
+  if (action === 'settings') return { kind: 'menu' }
+  return { kind: 'menu' }
+}

package/src/identity/identityCompat.ts

@@ -0,0 +1,34 @@
+const LEGACY_OWNER_ADDRESS_KEY = ['c', 'oldOwnerAddress'].join('')
+const OPERATOR_VAULT_ADDRESS_KEY = 'operatorVaultAddress'
+
+export function readOwnerAddressField(input: Record<string, unknown> | null | undefined): string | undefined {
+  const current = stringValue(input?.ownerAddress)
+  if (current) return current
+  return stringValue(input?.[LEGACY_OWNER_ADDRESS_KEY])
+}
+
+export function setOwnerAddressField(target: Record<string, unknown>, value: string): void {
+  delete target[LEGACY_OWNER_ADDRESS_KEY]
+  target.ownerAddress = value
+}
+
+export function clearOwnerAddressField(target: Record<string, unknown>): void {
+  delete target.ownerAddress
+  delete target[LEGACY_OWNER_ADDRESS_KEY]
+}
+
+export function readOperatorVaultAddressField(input: Record<string, unknown> | null | undefined): string | undefined {
+  return stringValue(input?.[OPERATOR_VAULT_ADDRESS_KEY])
+}
+
+export function setOperatorVaultAddressField(target: Record<string, unknown>, value: string): void {
+  target[OPERATOR_VAULT_ADDRESS_KEY] = value
+}
+
+export function clearOperatorVaultAddressField(target: Record<string, unknown>): void {
+  delete target[OPERATOR_VAULT_ADDRESS_KEY]
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}

package/src/identity/profile/agentIcon.ts

@@ -0,0 +1,61 @@
+import path from 'node:path'
+
+const AGENT_ICON_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.mp4', '.webm', '.mov'] as const
+
+export function validateAgentIconReference(input: string): string | null {
+  const trimmed = input.trim()
+  if (!trimmed) return 'enter an Agent Icon URL or local file path'
+  if (hasUnsupportedUrlScheme(trimmed)) return 'Agent Icon must be a local path, https URL, or ipfs:// URL'
+  if (!agentIconExtension(trimmed)) return 'Agent Icon must be png, jpg, jpeg, gif, webp, svg, mp4, webm, or mov'
+  return null
+}
+
+export function isAgentIconUrl(input: string): boolean {
+  return /^(https|ipfs):\/\//i.test(input.trim())
+}
+
+export function agentIconContentType(file: string): string {
+  const ext = path.extname(file).toLowerCase()
+  switch (ext) {
+    case '.png':
+      return 'image/png'
+    case '.jpg':
+    case '.jpeg':
+      return 'image/jpeg'
+    case '.gif':
+      return 'image/gif'
+    case '.webp':
+      return 'image/webp'
+    case '.svg':
+      return 'image/svg+xml'
+    case '.mp4':
+      return 'video/mp4'
+    case '.webm':
+      return 'video/webm'
+    case '.mov':
+      return 'video/quicktime'
+    default:
+      return 'application/octet-stream'
+  }
+}
+
+function agentIconExtension(input: string): string | null {
+  const pathname = isAgentIconUrl(input) ? urlPathname(input) : input
+  const ext = path.extname(pathname).toLowerCase()
+  return AGENT_ICON_EXTENSIONS.includes(ext as typeof AGENT_ICON_EXTENSIONS[number]) ? ext : null
+}
+
+function urlPathname(input: string): string {
+  try {
+    const url = new URL(input)
+    return `${url.hostname}${url.pathname}`
+  } catch {
+    return input.split(/[?#]/, 1)[0] ?? input
+  }
+}
+
+function hasUnsupportedUrlScheme(input: string): boolean {
+  const match = /^([a-z][a-z0-9+.-]*):\/\//i.exec(input)
+  if (!match) return false
+  return !/^(https|ipfs)$/i.test(match[1] ?? '')
+}

package/src/identity/profile/imagePicker.ts

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 
-export type ImageFilePickerResult =
+type ImageFilePickerResult =
   | { ok: true; file: string; method: string }
   | { ok: false; cancelled: boolean; error: string }
 
@@ -28,14 +28,14 @@ export async function openImageFilePicker(
       ok: false,
       cancelled: false,
       error: platform === 'linux'
-        ? 'install zenity or kdialog, or enter the image path manually'
-        : 'no native image picker is available; enter the image path manually',
+        ? 'install zenity or kdialog, or enter the icon path manually'
+        : 'no native icon picker is available; enter the icon path manually',
     }
   }
   const result = await runPickerCommand(command, options.spawnImpl ?? spawn, options.timeoutMs ?? 120_000)
   if (!result.ok) return result
   const file = result.file.trim()
-  if (!file) return { ok: false, cancelled: true, error: 'image selection cancelled' }
+  if (!file) return { ok: false, cancelled: true, error: 'icon selection cancelled' }
   return { ok: true, file, method: command.method }
 }
 
@@ -55,8 +55,8 @@ function resolveImagePickerCommand(platform: NodeJS.Platform, env: NodeJS.Proces
           '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
           'Add-Type -AssemblyName System.Windows.Forms',
           '$dialog = New-Object System.Windows.Forms.OpenFileDialog',
-          '$dialog.Title = "Choose agent image"',
-          '$dialog.Filter = "Images (*.png;*.jpg;*.jpeg;*.gif;*.webp;*.svg)|*.png;*.jpg;*.jpeg;*.gif;*.webp;*.svg|All files (*.*)|*.*"',
+          '$dialog.Title = "Choose Agent Icon"',
+          '$dialog.Filter = "Agent Icon (*.png;*.jpg;*.jpeg;*.gif;*.webp;*.svg;*.mp4;*.webm;*.mov)|*.png;*.jpg;*.jpeg;*.gif;*.webp;*.svg;*.mp4;*.webm;*.mov|All files (*.*)|*.*"',
           '$dialog.CheckFileExists = $true',
           'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { Write-Output $dialog.FileName }',
         ].join('; '),
@@ -69,7 +69,7 @@ function resolveImagePickerCommand(platform: NodeJS.Platform, env: NodeJS.Proces
       cmd: 'osascript',
       args: [
         '-e',
-        'set selectedFile to choose file with prompt "Choose agent image"',
+        'set selectedFile to choose file with prompt "Choose Agent Icon"',
         '-e',
         'POSIX path of selectedFile',
       ],
@@ -82,8 +82,8 @@ function resolveImagePickerCommand(platform: NodeJS.Platform, env: NodeJS.Proces
       cmd: zenity,
       args: [
         '--file-selection',
-        '--title=Choose agent image',
-        '--file-filter=Images | *.png *.jpg *.jpeg *.gif *.webp *.svg',
+        '--title=Choose Agent Icon',
+        '--file-filter=Agent Icon | *.png *.jpg *.jpeg *.gif *.webp *.svg *.mp4 *.webm *.mov',
       ],
       method: 'zenity',
     }
@@ -92,7 +92,7 @@ function resolveImagePickerCommand(platform: NodeJS.Platform, env: NodeJS.Proces
   if (kdialog) {
     return {
       cmd: kdialog,
-      args: ['--getopenfilename', '.', 'Images (*.png *.jpg *.jpeg *.gif *.webp *.svg)'],
+      args: ['--getopenfilename', '.', 'Agent Icon (*.png *.jpg *.jpeg *.gif *.webp *.svg *.mp4 *.webm *.mov)'],
       method: 'kdialog',
     }
   }
@@ -122,7 +122,7 @@ function runPickerCommand(
       if (settled) return
       settled = true
       child.kill()
-      resolve({ ok: false, cancelled: false, error: 'image picker timed out' })
+      resolve({ ok: false, cancelled: false, error: 'icon picker timed out' })
     }, timeoutMs)
     child.stdout?.setEncoding('utf8')
     child.stderr?.setEncoding('utf8')
@@ -145,7 +145,7 @@ function runPickerCommand(
       }
       const detail = stderr.trim()
       const cancelled = code === 0 || /cancel/i.test(detail)
-      resolve({ ok: false, cancelled, error: cancelled ? 'image selection cancelled' : detail || `${command.method} exited ${code}` })
+      resolve({ ok: false, cancelled, error: cancelled ? 'icon selection cancelled' : detail || `${command.method} exited ${code}` })
     })
   })
 }

package/src/identity/registry/erc8004/abi.ts

@@ -0,0 +1,14 @@
+import { parseAbi, parseAbiItem } from 'viem'
+
+export const ERC8004_ABI = parseAbi([
+  'function register(string agentURI) returns (uint256)',
+  'function balanceOf(address owner) view returns (uint256)',
+  'function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)',
+  'function ownerOf(uint256 tokenId) view returns (address)',
+  'function tokenURI(uint256 tokenId) view returns (string)',
+  'function setAgentURI(uint256 agentId, string newURI)',
+  'function getMetadata(uint256 agentId, string metadataKey) view returns (bytes)',
+])
+
+export const REGISTERED_EVENT = parseAbiItem('event Registered(uint256 indexed agentId, address indexed owner, string agentURI)')
+export const TRANSFER_EVENT = parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)')

package/src/identity/registry/erc8004/chains.ts

@@ -0,0 +1,150 @@
+import { getAddress, isAddress, type Address, type Chain } from 'viem'
+import { base, mainnet } from 'viem/chains'
+import type { SelectableNetwork } from '../../../storage/config.js'
+import type { Erc8004RegistryConfig } from './types.js'
+import { uniqueStrings } from './utils.js'
+
+export const DEFAULT_ERC8004_CHAIN_ID = 1
+export const DEFAULT_ETHEREUM_RPC_URL = 'https://ethereum.publicnode.com'
+export const DEFAULT_ERC8004_IDENTITY_REGISTRY_ADDRESS = '0x8004A169FB4a3325136EB29fA0ceB6D2e539a432'
+
+export type SupportedErc8004Chain = {
+  chainId: number
+  name: string
+  rpcUrl: string
+  fallbackRpcUrls: string[]
+  identityRegistryAddress?: Address
+  fromBlock?: bigint
+  logBlockRange: bigint
+  kind: 'mainnet' | 'l2'
+  network: SelectableNetwork
+}
+
+export const SUPPORTED_ERC8004_CHAINS: SupportedErc8004Chain[] = [
+  chainEntry(mainnet.id, 'Ethereum Mainnet', DEFAULT_ETHEREUM_RPC_URL,    [],                              DEFAULT_ERC8004_IDENTITY_REGISTRY_ADDRESS, 24_339_871n, 10_000n, 'mainnet', 'mainnet'),
+  chainEntry(base.id,    'Base',             'https://mainnet.base.org', ['https://base.publicnode.com'], DEFAULT_ERC8004_IDENTITY_REGISTRY_ADDRESS, 41_663_783n, 10_000n, 'l2',      'base'),
+]
+
+const NETWORK_TO_CHAIN_ID: Record<SelectableNetwork, number> = {
+  mainnet: mainnet.id,
+  base:    base.id,
+}
+
+export function chainIdForNetwork(network: SelectableNetwork): number {
+  return NETWORK_TO_CHAIN_ID[network]
+}
+
+export function networkForChainId(chainId: number): SelectableNetwork | undefined {
+  for (const [network, id] of Object.entries(NETWORK_TO_CHAIN_ID) as Array<[SelectableNetwork, number]>) {
+    if (id === chainId) return network
+  }
+  return undefined
+}
+
+export class MissingRegistryAddressError extends Error {
+  chainId: number
+  network?: SelectableNetwork
+  constructor(chainId: number) {
+    const network = networkForChainId(chainId)
+    super('no default ERC-8004 registry onchain ' + chainId + (network ? ' (' + network + ')' : ''))
+    this.name = 'MissingRegistryAddressError'
+    this.chainId = chainId
+    this.network = network
+  }
+}
+
+export function supportedErc8004ChainForId(chainId: number): SupportedErc8004Chain | undefined {
+  return SUPPORTED_ERC8004_CHAINS.find(chain => chain.chainId === chainId)
+}
+
+export function normalizeErc8004RegistryConfig(input: {
+  chainId?: number
+  rpcUrl?: string
+  identityRegistryAddress?: string
+  fromBlock?: string | bigint
+}): Erc8004RegistryConfig {
+  const chainId = input.chainId ?? DEFAULT_ERC8004_CHAIN_ID
+  const chain = supportedErc8004ChainForId(chainId)
+  const identityRegistryAddress = input.identityRegistryAddress?.trim() || chain?.identityRegistryAddress
+  if (!identityRegistryAddress) throw new MissingRegistryAddressError(chainId)
+  if (!isAddress(identityRegistryAddress)) throw new Error('Invalid agent registry address')
+  let parsedUrl: URL
+  try {
+    parsedUrl = new URL(input.rpcUrl?.trim() || chain?.rpcUrl || DEFAULT_ETHEREUM_RPC_URL)
+  } catch {
+    throw new Error('Invalid Ethereum RPC URL')
+  }
+  if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+    throw new Error('Ethereum RPC URL must be http(s)')
+  }
+  return {
+    chainId,
+    rpcUrl: parsedUrl.toString().replace(/\/$/, ''),
+    identityRegistryAddress: getAddress(identityRegistryAddress),
+    fromBlock: input.fromBlock !== undefined ? BigInt(input.fromBlock) : chain?.fromBlock,
+  }
+}
+
+export function erc8004ConfigForSupportedChain(chainId: number): Erc8004RegistryConfig {
+  const chain = supportedErc8004ChainForId(chainId)
+  if (!chain) throw new Error('Unsupported ERC-8004 chain id: ' + chainId)
+  return normalizeErc8004RegistryConfig(chain)
+}
+
+export function chainSortIndex(chainId: number): number {
+  const index = SUPPORTED_ERC8004_CHAINS.findIndex(chain => chain.chainId === chainId)
+  return index === -1 ? Number.MAX_SAFE_INTEGER : index
+}
+
+export function logBlockRangeForChain(chainId: number): bigint {
+  const chain = supportedErc8004ChainForId(chainId)
+  if (!chain) return 10_000n
+  return chain.logBlockRange
+}
+
+export function minLogBlockRangeForChain(chainId: number): bigint {
+  const chain = supportedErc8004ChainForId(chainId)
+  if (!chain) return 2_000n
+  return chain.kind === 'l2' ? chain.logBlockRange : chain.logBlockRange / 2n || 1n
+}
+
+export function rpcUrlsForClient(args: Pick<Erc8004RegistryConfig, 'chainId' | 'rpcUrl'>): string[] {
+  const chain = supportedErc8004ChainForId(args.chainId)
+  return uniqueStrings([
+    args.rpcUrl,
+    ...(chain && args.rpcUrl !== chain.rpcUrl ? [chain.rpcUrl] : []),
+    ...(chain?.fallbackRpcUrls ?? []),
+  ])
+}
+
+export function chainForId(chainId: number): Chain | undefined {
+  switch (chainId) {
+    case mainnet.id: return mainnet
+    case base.id:    return base
+    default:         return undefined
+  }
+}
+
+function chainEntry(
+  chainId: number,
+  name: string,
+  rpcUrl: string,
+  fallbackRpcUrls: string[],
+  identityRegistryAddress: string | undefined,
+  fromBlock: bigint | undefined,
+  logBlockRange: bigint,
+  kind: SupportedErc8004Chain['kind'],
+  network: SelectableNetwork,
+): SupportedErc8004Chain {
+  return {
+    chainId,
+    name,
+    rpcUrl: rpcUrl.replace(/\/$/, ''),
+    fallbackRpcUrls: fallbackRpcUrls.map(url => url.replace(/\/$/, '')),
+    ...(identityRegistryAddress ? { identityRegistryAddress: getAddress(identityRegistryAddress) } : {}),
+    ...(fromBlock !== undefined ? { fromBlock } : {}),
+    logBlockRange,
+    kind,
+    network,
+  }
+}

package/src/identity/registry/erc8004/client.ts

@@ -0,0 +1,11 @@
+import { createPublicClient, fallback, http, type PublicClient } from 'viem'
+import type { Erc8004RegistryConfig } from './types.js'
+import { chainForId, rpcUrlsForClient } from './chains.js'
+
+export function createErc8004PublicClient(args: Pick<Erc8004RegistryConfig, 'chainId' | 'rpcUrl'>): PublicClient {
+  const transports = rpcUrlsForClient(args).map(url => http(url, { retryCount: 0, timeout: 8_000 }))
+  return createPublicClient({
+    chain: chainForId(args.chainId),
+    transport: transports.length === 1 ? transports[0]! : fallback(transports, { retryCount: 0 }),
+  })
+}