ethagent 1.1.1 → 2.0.0

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

@@ -0,0 +1,88 @@
+import type { Address, PublicClient } from 'viem'
+import type { TransferSnapshotMetadata } from '../../../storage/config.js'
+import type { WalletContinuityRestoreAccessKey } from '../../continuity/envelope.js'
+
+export type FetchLike = typeof fetch
+
+export type Erc8004RegistryConfig = {
+  chainId: number
+  rpcUrl: string
+  identityRegistryAddress: Address
+  fromBlock?: bigint
+}
+
+export type EthagentBackupPointer = {
+  cid: string
+  envelopeVersion?: string
+  createdAt?: string
+  agentAddress?: Address
+  transferSnapshot?: TransferSnapshotMetadata
+  pastBackups?: Array<{ cid: string; createdAt?: string }>
+}
+
+export type EthagentPublicDiscoveryPointer = {
+  skillsCid?: string
+  agentCardCid?: string
+  updatedAt?: string
+}
+
+export type EthagentRegistrationPointer = {
+  chainId: number
+  identityRegistryAddress: Address
+  agentId?: string | number
+}
+
+export type ApprovedOperatorWalletRecord = {
+  address: Address
+  challenge?: string
+  verifiedAt?: string
+  restoreAccessKey?: WalletContinuityRestoreAccessKey
+}
+
+export type EthagentOperatorsPointer = {
+  approvedOperatorWallets: ApprovedOperatorWalletRecord[]
+  activeOperatorAddress?: Address
+  ownerAddress?: Address
+  ensName?: string
+  restoreAccessEpoch?: number
+  ownerRestoreAccessKey?: WalletContinuityRestoreAccessKey
+}
+
+export type EthagentX402Pointer = {
+  walletAddress: Address
+}
+
+export type Erc8004AgentCandidate = {
+  tokenOwnerAddress?: Address
+  ownerAddress: Address
+  chainId: number
+  rpcUrl: string
+  identityRegistryAddress: Address
+  agentId: bigint
+  agentUri: string
+  metadataCid?: string
+  name?: string
+  description?: string
+  imageUrl?: string
+  backup?: EthagentBackupPointer
+  publicDiscovery?: EthagentPublicDiscoveryPointer
+  operators?: EthagentOperatorsPointer
+  registration: Record<string, unknown> | null
+}
+
+export type DiscoverOwnedAgentsArgs = Erc8004RegistryConfig & {
+  ownerHandle: string
+  ipfsApiUrl?: string
+  publicClient?: PublicClient
+  fetchImpl?: FetchLike
+  signal?: AbortSignal
+}
+
+export type DiscoverOwnedAgentsAcrossSupportedNetworksArgs = {
+  ownerHandle: string
+  registryOverrides?: Erc8004RegistryConfig[]
+  ipfsApiUrl?: string
+  publicClients?: Partial<Record<number, PublicClient>>
+  fetchImpl?: FetchLike
+  signal?: AbortSignal
+}

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

@@ -0,0 +1,59 @@
+import { catFromIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
+import type { FetchLike } from './types.js'
+import { decodeDataUri, parseJsonObject } from './utils.js'
+
+export async function loadAgentRegistration(
+  uri: string,
+  args: { ipfsApiUrl?: string; fetchImpl?: FetchLike; signal?: AbortSignal } = {},
+): Promise<{ metadataCid?: string; registration: Record<string, unknown> }> {
+  const trimmed = uri.trim()
+  let raw: string
+  if (trimmed.startsWith('ipfs://')) {
+    const cid = cidFromUri(trimmed)
+    if (!cid) throw new Error('AgentURI is missing an IPFS CID')
+    raw = new TextDecoder().decode(await catFromIpfs(
+      args.ipfsApiUrl ?? DEFAULT_IPFS_API_URL,
+      cid,
+      args.fetchImpl,
+      args.signal ? { signal: args.signal } : {},
+    ))
+    return { metadataCid: cid, registration: parseJsonObject(raw) }
+  }
+  if (trimmed.startsWith('data:')) {
+    return { registration: parseJsonObject(decodeDataUri(trimmed)) }
+  }
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+    const response = await (args.fetchImpl ?? fetch)(trimmed, args.signal ? { signal: args.signal } : {})
+    if (!response.ok) throw new Error('agent token URI fetch failed: ' + response.status + ' ' + response.statusText)
+    return { registration: parseJsonObject(await response.text()) }
+  }
+  throw new Error('Unsupported agentURI scheme')
+}
+
+export function cidFromUri(uri: string): string | undefined {
+  if (!uri.startsWith('ipfs://')) return undefined
+  const withoutScheme = uri.slice('ipfs://'.length)
+  return withoutScheme.startsWith('ipfs/') ? withoutScheme.slice('ipfs/'.length) : withoutScheme
+}
+
+export async function loadAgentRegistrationWithRetry(
+  agentUri: string,
+  args: { ipfsApiUrl?: string; fetchImpl?: FetchLike; signal?: AbortSignal },
+  attempts = 3,
+): Promise<{ metadataCid?: string; registration: Record<string, unknown> }> {
+  let lastErr: unknown
+  for (let i = 0; i < attempts; i++) {
+    if (args.signal?.aborted) throw new DOMException('discovery cancelled', 'AbortError')
+    try {
+      return await loadAgentRegistration(agentUri, args)
+    } catch (err: unknown) {
+      if (args.signal?.aborted || (err instanceof Error && err.name === 'AbortError')) throw err
+      lastErr = err
+      if (i < attempts - 1) {
+        const backoffMs = (i + 1) * 500
+        await new Promise(r => setTimeout(r, backoffMs))
+      }
+    }
+  }
+  throw lastErr
+}

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

@@ -0,0 +1,58 @@
+import { formatEther } from 'viem'
+
+export function uniqueStrings(values: string[]): string[] {
+  const out: string[] = []
+  for (const value of values) {
+    const normalized = value.trim().replace(/\/$/, '')
+    if (normalized && !out.includes(normalized)) out.push(normalized)
+  }
+  return out
+}
+
+export function cleanRpcError(err: unknown): string {
+  const message = err instanceof Error ? err.message : String(err)
+  return message
+    .replace(/s+/g, ' ')
+    .slice(0, 220)
+}
+
+export function formatEthAmount(wei: bigint): string {
+  const [whole = '0', fraction = ''] = formatEther(wei).split('.')
+  const trimmedFraction = fraction.slice(0, 6).replace(/0+$/, '')
+  return trimmedFraction ? whole + '.' + trimmedFraction : whole
+}
+
+export function parseJsonObject(raw: string): Record<string, unknown> {
+  const parsed = JSON.parse(raw) as unknown
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('Agent token URI must resolve to a JSON object')
+  }
+  return parsed as Record<string, unknown>
+}
+
+export function decodeDataUri(uri: string): string {
+  const comma = uri.indexOf(',')
+  if (comma === -1) throw new Error('Invalid data URI')
+  const meta = uri.slice(0, comma)
+  const body = uri.slice(comma + 1)
+  return meta.endsWith(';base64')
+    ? Buffer.from(body, 'base64').toString('utf8')
+    : decodeURIComponent(body)
+}
+
+export async function mapWithConcurrency<input, output>(
+  inputs: input[],
+  concurrency: number,
+  mapper: (input: input) => Promise<output>,
+): Promise<output[]> {
+  const out: output[] = new Array(inputs.length)
+  let next = 0
+  const workers = Array.from({ length: Math.min(concurrency, inputs.length) }, async () => {
+    while (next < inputs.length) {
+      const index = next++
+      out[index] = await mapper(inputs[index]!)
+    }
+  })
+  await Promise.all(workers)
+  return out
+}