ethagent 1.1.1 → 2.0.0

package/src/identity/hub/reconciliation/walletSetup.ts

@@ -0,0 +1,220 @@
+import {
+  createPublicClient,
+  encodeFunctionData,
+  fallback,
+  getAddress,
+  http,
+  namehash,
+  type Address,
+  type Hex,
+  type PublicClient,
+} from 'viem'
+import { mainnet } from 'viem/chains'
+import type { EthagentIdentity } from '../../../storage/config.js'
+import type { Erc8004RegistryConfig } from '../../registry/erc8004.js'
+import { ENS_AUTOMATION_RESOLVER_ABI } from '../../ens/ensAutomation.js'
+import { encodeApprove, encodeApprovalRevoke, readDelegation } from '../../ens/resolverDelegation.js'
+import { readResolverAddress } from '../../ens/ensLookup.js'
+import { normalizeApprovedOperatorWallets } from '../operatorWallets.js'
+import { readCustodyMode } from '../model/custody.js'
+import { readOwnerAddressField } from '../../identityCompat.js'
+
+export type ApprovalDiff = {
+  added: Address[]
+  removed: Address[]
+}
+
+export function computeApprovalDiff(
+  beforeApproved: ReadonlyArray<{ address: string }>,
+  afterApproved: ReadonlyArray<{ address: string }>,
+): ApprovalDiff {
+  const before = new Set(beforeApproved.map(record => record.address.toLowerCase()))
+  const after = new Set(afterApproved.map(record => record.address.toLowerCase()))
+  const added: Address[] = []
+  const removed: Address[] = []
+  for (const record of afterApproved) {
+    if (!before.has(record.address.toLowerCase())) {
+      added.push(getAddress(record.address))
+    }
+  }
+  for (const record of beforeApproved) {
+    if (!after.has(record.address.toLowerCase())) {
+      removed.push(getAddress(record.address))
+    }
+  }
+  return { added, removed }
+}
+
+type ResolverApprovalCalls = {
+  resolverAddress: Address
+  data: Hex
+  calls: Hex[]
+  added: Address[]
+  removed: Address[]
+}
+
+export async function encodeResolverApprovalChanges(args: {
+  ensName: string
+  diff: ApprovalDiff
+}): Promise<ResolverApprovalCalls | null> {
+  if (args.diff.added.length === 0 && args.diff.removed.length === 0) return null
+  const resolverAddress = await readResolverAddress(args.ensName)
+  if (!resolverAddress) {
+    throw new Error(`no resolver set on ${args.ensName} - finish ENS subdomain setup first`)
+  }
+  const node = namehash(args.ensName)
+  const calls: Hex[] = []
+  for (const address of args.diff.added) calls.push(encodeApprove(node, address))
+  for (const address of args.diff.removed) calls.push(encodeApprovalRevoke(node, address))
+  const data = calls.length === 1
+    ? calls[0]!
+    : encodeFunctionData({
+        abi: ENS_AUTOMATION_RESOLVER_ABI,
+        functionName: 'multicall',
+        args: [calls],
+      })
+  return {
+    resolverAddress,
+    data,
+    calls,
+    added: args.diff.added,
+    removed: args.diff.removed,
+  }
+}
+
+export type RecordsFixPlanItem =
+  | { kind: 'missing-approval'; address: Address }
+  | { kind: 'stale-approval'; address: Address }
+  | { kind: 'no-resolver' }
+  | { kind: 'no-ens' }
+
+export type RecordsFixPlan = {
+  identityAgentId: string
+  ensName: string | undefined
+  items: RecordsFixPlanItem[]
+}
+
+type ReconcileArgs = {
+  identity: EthagentIdentity
+  registry: Erc8004RegistryConfig
+  client?: Pick<PublicClient, 'readContract'>
+}
+
+export async function reconcileWalletSetup(
+  args: ReconcileArgs,
+): Promise<RecordsFixPlan> {
+  const baseState = (args.identity.state ?? {}) as Record<string, unknown>
+  const ensName = typeof baseState.ensName === 'string' ? baseState.ensName.trim() : ''
+  const custodyMode = readCustodyMode(baseState)
+  const approved = normalizeApprovedOperatorWallets(baseState.approvedOperatorWallets)
+  const items: RecordsFixPlanItem[] = []
+
+  if (custodyMode !== 'advanced' || approved.length === 0) {
+    return { identityAgentId: String(args.identity.agentId ?? ''), ensName: ensName || undefined, items }
+  }
+  if (!ensName) {
+    items.push({ kind: 'no-ens' })
+    return { identityAgentId: String(args.identity.agentId ?? ''), ensName: undefined, items }
+  }
+
+  let resolverAddress: Address | null
+  try {
+    resolverAddress = await readResolverAddress(ensName)
+  } catch {
+    resolverAddress = null
+  }
+  if (!resolverAddress) {
+    items.push({ kind: 'no-resolver' })
+    return { identityAgentId: String(args.identity.agentId ?? ''), ensName, items }
+  }
+
+  const ownerAddress = readOwnerAddressField(baseState) ?? args.identity.ownerAddress ?? args.identity.address
+  const node = namehash(ensName)
+
+  for (const record of approved) {
+    const isApproved = await readDelegation({
+      client: args.client ?? createReadClient(),
+      resolverAddress,
+      ownerAddress: getAddress(ownerAddress),
+      node,
+      delegateAddress: getAddress(record.address),
+    })
+    if (!isApproved) {
+      items.push({ kind: 'missing-approval', address: getAddress(record.address) })
+    }
+  }
+
+  return { identityAgentId: String(args.identity.agentId ?? ''), ensName, items }
+}
+
+function createReadClient(): Pick<PublicClient, 'readContract'> {
+  const transports = [
+    http('https://ethereum.publicnode.com', { retryCount: 0, timeout: 8_000 }),
+    http('https://eth.llamarpc.com', { retryCount: 0, timeout: 8_000 }),
+  ]
+  return createPublicClient({
+    chain: mainnet,
+    transport: fallback(transports, { retryCount: 0 }),
+  })
+}
+
+type VerifyResolverApprovalsArgs = {
+  ensName: string
+  ownerAddress: Address
+  resolverAddress: Address
+  added: ReadonlyArray<Address>
+  removed: ReadonlyArray<Address>
+  client?: Pick<PublicClient, 'readContract'>
+}
+
+export async function verifyResolverApprovalsLanded(args: VerifyResolverApprovalsArgs): Promise<void> {
+  if (args.added.length === 0 && args.removed.length === 0) return
+  const client = args.client ?? createReadClient()
+  const node = namehash(args.ensName)
+  const owner = getAddress(args.ownerAddress)
+  for (const address of args.added) {
+    const delegate = getAddress(address)
+    const isApproved = await readDelegation({
+      client,
+      resolverAddress: args.resolverAddress,
+      ownerAddress: owner,
+      node,
+      delegateAddress: delegate,
+    })
+    if (!isApproved) {
+      throw new Error(`Resolver delegation didn't land for operator wallet ${delegate}. Your wallet may have rejected the inner operation; retry by selecting Fix Records again.`)
+    }
+  }
+  for (const address of args.removed) {
+    const delegate = getAddress(address)
+    const isApproved = await readDelegation({
+      client,
+      resolverAddress: args.resolverAddress,
+      ownerAddress: owner,
+      node,
+      delegateAddress: delegate,
+    })
+    if (isApproved) {
+      throw new Error(`Resolver revocation didn't land for operator wallet ${delegate}. Your wallet may have rejected the inner operation; retry by selecting Fix Records again.`)
+    }
+  }
+}
+
+export function fixPlanRequiresOwnerWallet(plan: RecordsFixPlan): boolean {
+  return plan.items.some(item =>
+    item.kind === 'missing-approval' || item.kind === 'stale-approval',
+  )
+}
+
+export function describeFixPlanItem(item: RecordsFixPlanItem): string {
+  switch (item.kind) {
+    case 'missing-approval':
+      return `operator wallet ${item.address} has no onchain resolver approval, record writes will be rejected`
+    case 'stale-approval':
+      return `operator wallet ${item.address} has an onchain approval that no longer matches the operator set`
+    case 'no-resolver':
+      return 'ENS subdomain has no resolver set yet, finish ENS setup before authorizing operator wallets onchain'
+    case 'no-ens':
+      return 'advanced mode requires an ENS subdomain so operator wallets can sign profile updates onchain'
+  }
+}

package/src/identity/hub/txGuard.ts

@@ -0,0 +1,51 @@
+export type TxGuardKind =
+  | 'rebackup'
+  | 'public-profile'
+  | 'vault-deploy'
+  | 'vault-deposit'
+  | 'vault-unwrap'
+  | 'vault-withdraw'
+
+export class TxGuardBusyError extends Error {
+  readonly kind: TxGuardKind
+  constructor(kind: TxGuardKind, message: string) {
+    super(message)
+    this.name = 'TxGuardBusyError'
+    this.kind = kind
+  }
+}
+
+const inFlight = new Set<TxGuardKind>()
+
+export function isTxGuardBusy(kind: TxGuardKind): boolean {
+  return inFlight.has(kind)
+}
+
+export function acquireTxGuard(kind: TxGuardKind): void {
+  inFlight.add(kind)
+}
+
+export function releaseTxGuard(kind: TxGuardKind): void {
+  inFlight.delete(kind)
+}
+
+export function resetTxGuardForTest(): void {
+  inFlight.clear()
+}
+
+export function txGuardBusyMessage(kind: TxGuardKind): string {
+  switch (kind) {
+    case 'rebackup':
+      return 'A snapshot save is already in flight. Wait for it to complete before retrying.'
+    case 'public-profile':
+      return 'A public profile update is already in flight. Wait for it to complete before retrying.'
+    case 'vault-deploy':
+      return 'A vault deploy transaction is already in flight. Wait for it to complete before retrying.'
+    case 'vault-deposit':
+      return 'A vault deposit transaction is already in flight. Wait for it to complete before retrying.'
+    case 'vault-unwrap':
+      return 'A vault unwrap transaction is already in flight. Wait for it to complete before retrying.'
+    case 'vault-withdraw':
+      return 'A token withdraw transaction is already in flight. Wait for it to complete before retrying.'
+  }
+}

package/src/identity/hub/types.ts

@@ -0,0 +1,17 @@
+import type { EthagentConfig, EthagentIdentity } from '../../storage/config.js'
+
+export type IdentityHubResult =
+  | { kind: 'token'; identity: EthagentIdentity }
+  | { kind: 'updated'; config: EthagentConfig; message: string }
+  | { kind: 'skip' }
+  | { kind: 'cancel' }
+
+export type IdentityHubInitialAction = 'create' | 'load' | 'settings' | 'save-snapshot' | 'save-prompt'
+
+export type IdentityHubProps = {
+  mode: 'first-run' | 'manage'
+  config?: EthagentConfig
+  initialAction?: IdentityHubInitialAction
+  onComplete: (result: IdentityHubResult) => void
+  onConfigChange?: (config: EthagentConfig) => void
+}

package/src/identity/hub/useIdentityHubContinuity.ts

@@ -0,0 +1,136 @@
+import { useEffect, useState } from 'react'
+import type { EthagentIdentity } from '../../storage/config.js'
+import { catFromIpfs, DEFAULT_IPFS_API_URL } from '../storage/ipfs.js'
+import {
+  continuityVaultRef,
+  continuityVaultStatus,
+  continuityWorkingTreeStatus,
+  ensurePublicSkillsFile,
+  type ContinuityWorkingTreeStatus,
+} from '../continuity/storage.js'
+import { openFileInEditor } from '../continuity/editor.js'
+import { exportLocalBackup } from '../continuity/localBackup.js'
+import { listPublishedContinuitySnapshots } from '../continuity/snapshots.js'
+import type { Step } from './identityHubReducer.js'
+
+type UseIdentityHubContinuityArgs = {
+  identity: EthagentIdentity | undefined
+  step: Step
+  setStep: (step: Step) => void
+  handleStepError: (err: unknown, backStep: Step, softCancel?: Step) => void
+}
+
+export function useIdentityHubContinuity({
+  identity,
+  step,
+  setStep,
+  handleStepError,
+}: UseIdentityHubContinuityArgs): {
+  continuityReady: boolean
+  setContinuityReady: (ready: boolean) => void
+  workingStatus: ContinuityWorkingTreeStatus | null
+  openContinuityFile: (kind: 'soul' | 'memory' | 'skills') => Promise<void>
+  exportLocalBackupZip: () => Promise<void>
+} {
+  const [continuityReady, setContinuityReady] = useState<boolean>(false)
+  const [workingStatus, setWorkingStatus] = useState<ContinuityWorkingTreeStatus | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) {
+      setContinuityReady(false)
+      return
+    }
+    if (!step.kind.startsWith('continuity') && step.kind !== 'details' && step.kind !== 'menu') return
+    continuityVaultStatus(identity)
+      .then(status => { if (!cancelled) setContinuityReady(status.ready) })
+      .catch(() => { if (!cancelled) setContinuityReady(false) })
+    return () => { cancelled = true }
+  }, [identity, step.kind])
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) return
+    if (
+      step.kind !== 'menu'
+      && step.kind !== 'continuity-private'
+      && step.kind !== 'continuity-public'
+      && step.kind !== 'save-prompt'
+      && step.kind !== 'rebackup-confirm'
+    ) return
+
+    const checkStatus = async () => {
+      try {
+        const [latest] = await listPublishedContinuitySnapshots(identity, 1)
+        const status = await continuityWorkingTreeStatus(identity, latest)
+        if (cancelled) return
+        setWorkingStatus(status)
+      } catch {
+        if (cancelled) return
+        setWorkingStatus(null)
+      }
+    }
+
+    void checkStatus()
+
+    return () => {
+      cancelled = true
+    }
+  }, [identity, step.kind])
+
+  const openContinuityFile = async (kind: 'soul' | 'memory' | 'skills'): Promise<void> => {
+    if (!identity) return
+    try {
+      if (kind === 'skills') {
+        await ensurePublicSkillsFile(identity, {
+          fallback: () => readPublishedPublicSkills(identity),
+        })
+      }
+      const ref = continuityVaultRef(identity)
+      const file = kind === 'soul' ? ref.soulPath : kind === 'memory' ? ref.memoryPath : ref.publicSkillsPath
+      const result = await openFileInEditor(file)
+      const displayName = kind === 'soul' ? 'SOUL.md' : kind === 'memory' ? 'MEMORY.md' : 'skills.json'
+      const message = result.ok
+        ? `opened ${displayName} with ${result.method}.`
+        : `open failed: ${result.error}`
+      setStep({ kind: 'continuity-private', notice: message, editorOpened: result.ok })
+    } catch (err: unknown) {
+      handleStepError(err, { kind: 'continuity-private' })
+    }
+  }
+
+  const exportLocalBackupZip = async (): Promise<void> => {
+    if (!identity) return
+    try {
+      await ensurePublicSkillsFile(identity, {
+        fallback: () => readPublishedPublicSkills(identity),
+      })
+      const result = await exportLocalBackup(identity)
+      const message = result.ok
+        ? `Saved local backup to ${result.path}`
+        : result.cancelled
+          ? 'Backup cancelled'
+          : `Backup failed: ${result.error}`
+      setStep({ kind: 'continuity-private', notice: message })
+    } catch (err: unknown) {
+      handleStepError(err, { kind: 'continuity-private' })
+    }
+  }
+
+  return {
+    continuityReady,
+    setContinuityReady,
+    workingStatus,
+    openContinuityFile,
+    exportLocalBackupZip,
+  }
+}
+
+async function readPublishedPublicSkills(identity: EthagentIdentity): Promise<string> {
+  const cid = identity.publicSkills?.cid
+  if (!cid) throw new Error('No saved public skills CID')
+  return new TextDecoder().decode(await catFromIpfs(
+    identity.backup?.ipfsApiUrl ?? DEFAULT_IPFS_API_URL,
+    cid,
+  ))
+}