ethagent 1.1.2 → 2.0.1

package/src/identity/hub/effects/ens/transactions.ts

@@ -0,0 +1,239 @@
+import type { Address, Hex, PublicClient } from 'viem'
+import {
+  DEFAULT_ETHEREUM_RPC_URL,
+  RegisterAgentPreflightError,
+  createErc8004PublicClient,
+  supportedErc8004ChainForId,
+} from '../../../registry/erc8004.js'
+import { encodeSetEthagentTextRecords } from '../../../ens/ensLookup.js'
+import { encodeEnsRecordsTransaction, encodeEnsRegistryTransaction, type EnsSetupPlan } from '../../../ens/ensAutomation.js'
+import type { AgentEnsRecordState, AgentEnsRecords } from '../../../ens/agentRecords.js'
+import { changedRecords } from '../../../ens/agentRecords.js'
+import { sendBrowserWalletTransaction, type BrowserWalletSession, type WalletPurpose } from '../../../wallet/browserWallet.js'
+import type { EffectCallbacks } from '../types.js'
+function chainLabel(chainId: number): string {
+  return supportedErc8004ChainForId(chainId)?.name ?? `chain ${chainId}`
+}
+
+function ensTokenChainName(chainId: number): string | undefined {
+  return chainId !== 1 ? chainLabel(chainId) : undefined
+}
+
+export async function runUpdateEnsRecords(args: {
+  fullName: string
+  ownerAddress: Address
+  records: AgentEnsRecords
+  currentRecords?: AgentEnsRecordState
+  callbacks: EffectCallbacks
+  purpose?: WalletPurpose
+  clearRecords?: boolean
+  publicClient?: PublicClient
+  tokenChainId?: number
+  session?: BrowserWalletSession
+  flowId?: string
+  flowStep?: number
+}): Promise<{ txHash: string }> {
+  const next = ensRecordWritesForUpdate({
+    records: args.records,
+    currentRecords: args.currentRecords,
+    clearRecords: args.clearRecords,
+  })
+  if (Object.keys(next).length === 0) {
+    throw new Error('No ENS records to update')
+  }
+  const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
+  const encoded = await encodeSetEthagentTextRecords(args.fullName, next, { publicClient })
+  await preflightEnsRecordTransaction({
+    fullName: args.fullName,
+    account: args.ownerAddress,
+    to: encoded.resolverAddress,
+    data: encoded.data,
+    publicClient,
+    purpose: args.purpose ?? 'update-ens-records',
+  })
+  const tokenChainName = typeof args.tokenChainId === 'number' ? ensTokenChainName(args.tokenChainId) : undefined
+  const purpose = args.purpose ?? 'update-ens-records'
+  if (args.session) {
+    const result = await args.session.sendTransaction({
+      chainId: 1,
+      expectedAccount: args.ownerAddress,
+      to: encoded.resolverAddress,
+      data: encoded.data,
+      purpose,
+      ...(tokenChainName ? { tokenChainName } : {}),
+      ...(args.flowId ? { flowId: args.flowId } : {}),
+    })
+    return { txHash: result.txHash }
+  }
+  const result = await sendBrowserWalletTransaction({
+    chainId: 1,
+    expectedAccount: args.ownerAddress,
+    to: encoded.resolverAddress,
+    data: encoded.data,
+    purpose,
+    onReady: args.callbacks.onWalletReady,
+    ...(tokenChainName ? { tokenChainName } : {}),
+  })
+  args.callbacks.onWalletReady(null)
+  return { txHash: result.txHash }
+}
+
+export function ensRecordWritesForUpdate(args: {
+  records: AgentEnsRecords
+  currentRecords?: AgentEnsRecordState
+  clearRecords?: boolean
+}): Record<string, string> {
+  if (args.clearRecords) {
+    return changedRecords(args.currentRecords ?? {}, { token: '', profile: '' })
+  }
+  return changedRecords(args.currentRecords ?? { token: '', profile: '' }, args.records)
+}
+
+export async function runEnsSetupRegistryTransaction(args: {
+  setup: EnsSetupPlan
+  callbacks: EffectCallbacks
+  publicClient?: PublicClient
+  tokenChainId?: number
+  session?: BrowserWalletSession
+  flowId?: string
+  flowStep?: number
+}): Promise<{ txHash: string } | null> {
+  const encoded = encodeEnsRegistryTransaction(args.setup)
+  if (!encoded) return null
+  const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
+  const purpose: WalletPurpose = args.setup.mode === 'simple' ? 'create-simple-ens-subdomain' : 'create-agent-ens-subdomain'
+  await preflightEnsRecordTransaction({
+    fullName: args.setup.fullName,
+    account: args.setup.ownerAddress,
+    to: encoded.to,
+    data: encoded.data,
+    publicClient,
+    purpose,
+  })
+  const tokenChainName = typeof args.tokenChainId === 'number' ? ensTokenChainName(args.tokenChainId) : undefined
+  if (args.session) {
+    const result = await args.session.sendTransaction({
+      chainId: 1,
+      expectedAccount: args.setup.ownerAddress,
+      to: encoded.to,
+      data: encoded.data,
+      purpose,
+      ...(tokenChainName ? { tokenChainName } : {}),
+      ...(args.flowId ? { flowId: args.flowId } : {}),
+      ...(typeof args.flowStep === 'number' ? { flowStep: args.flowStep } : {}),
+    })
+    await publicClient.waitForTransactionReceipt({ hash: result.txHash })
+    return { txHash: result.txHash }
+  }
+  const result = await sendBrowserWalletTransaction({
+    chainId: 1,
+    expectedAccount: args.setup.ownerAddress,
+    to: encoded.to,
+    data: encoded.data,
+    purpose,
+    onReady: args.callbacks.onWalletReady,
+    ...(tokenChainName ? { tokenChainName } : {}),
+  })
+  args.callbacks.onWalletReady(null)
+  await publicClient.waitForTransactionReceipt({ hash: result.txHash })
+  return { txHash: result.txHash }
+}
+
+export async function runEnsSetupRecordsTransaction(args: {
+  setup: EnsSetupPlan
+  callbacks: EffectCallbacks
+  publicClient?: PublicClient
+  tokenChainId?: number
+  session?: BrowserWalletSession
+  flowId?: string
+  flowStep?: number
+}): Promise<{ txHash: string } | null> {
+  const encoded = encodeEnsRecordsTransaction(args.setup)
+  if (!encoded) return null
+  const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
+  const purpose: WalletPurpose = args.setup.mode === 'simple' ? 'set-simple-ens-records' : 'set-agent-ens-records'
+  await preflightEnsRecordTransaction({
+    fullName: args.setup.fullName,
+    account: args.setup.ownerAddress,
+    to: encoded.to,
+    data: encoded.data,
+    publicClient,
+    purpose,
+  })
+  const tokenChainName = typeof args.tokenChainId === 'number' ? ensTokenChainName(args.tokenChainId) : undefined
+  if (args.session) {
+    const result = await args.session.sendTransaction({
+      chainId: 1,
+      expectedAccount: args.setup.ownerAddress,
+      to: encoded.to,
+      data: encoded.data,
+      purpose,
+      ...(tokenChainName ? { tokenChainName } : {}),
+      ...(args.flowId ? { flowId: args.flowId } : {}),
+      ...(typeof args.flowStep === 'number' ? { flowStep: args.flowStep } : {}),
+    })
+    return { txHash: result.txHash }
+  }
+  const result = await sendBrowserWalletTransaction({
+    chainId: 1,
+    expectedAccount: args.setup.ownerAddress,
+    to: encoded.to,
+    data: encoded.data,
+    purpose,
+    onReady: args.callbacks.onWalletReady,
+    ...(tokenChainName ? { tokenChainName } : {}),
+  })
+  args.callbacks.onWalletReady(null)
+  return { txHash: result.txHash }
+}
+
+export function createMainnetEnsPublicClient(): PublicClient {
+  return createErc8004PublicClient({
+    chainId: 1,
+    rpcUrl: DEFAULT_ETHEREUM_RPC_URL,
+  })
+}
+
+async function preflightEnsRecordTransaction(args: {
+  fullName: string
+  account: Address
+  to: Address
+  data: Hex
+  publicClient: Pick<PublicClient, 'estimateGas'>
+  purpose: WalletPurpose
+}): Promise<void> {
+  try {
+    await args.publicClient.estimateGas({
+      account: args.account,
+      to: args.to,
+      data: args.data,
+    })
+  } catch (err: unknown) {
+    throw new RegisterAgentPreflightError({
+      code: 'simulation-failed',
+      title: ensPreflightErrorTitle(args.purpose),
+      detail: cleanPreflightError(err),
+      hint: ensPreflightErrorHint(args),
+    })
+  }
+}
+
+function ensPreflightErrorTitle(_purpose: WalletPurpose): string {
+  return 'ENS Record Update Blocked'
+}
+
+function ensPreflightErrorHint(args: {
+  fullName: string
+  purpose: WalletPurpose
+}): string {
+  const wallet = args.purpose === 'set-simple-ens-records' || args.purpose === 'update-ens-records' || args.purpose === 'clear-ens-records'
+    ? 'ENS owner wallet'
+    : 'owner wallet'
+  return `No transaction was sent. Connect the ${wallet} and confirm it can write ENS resolver records on ${args.fullName}.`
+}
+
+function cleanPreflightError(err: unknown): string {
+  return (err instanceof Error ? err.message : String(err))
+    .replace(/\s+/g, ' ')
+    .slice(0, 220)
+}

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

@@ -0,0 +1,74 @@
+export type {
+  CustodySwitchAdvancedProgress,
+  EffectCallbacks,
+  EnsClearProgress,
+  EnsLinkProgress,
+  EnsUpdateProgress,
+  IdentityCompletionSource,
+  RestoreProgress,
+  TokenTransferProgress,
+} from './types.js'
+export { awaitConfirmedReceipt } from './receipts.js'
+export {
+  ensRecordWritesForUpdate,
+  runEnsLinkFlow,
+  runEnsSetupRecordsTransaction,
+  runEnsSetupRegistryTransaction,
+  runEnsUnlinkFlow,
+  runEnsUpdateFlow,
+  runUpdateEnsRecords,
+} from './ens/index.js'
+export {
+  applyEnsValidationState,
+  applyOperatorProfileState,
+} from './profile/profileState.js'
+export {
+  canRestoreCandidate,
+  resolveAgentEnsToCandidate,
+  resolveAgentTokenIdToCandidate,
+  restoreSignatureRequestForStep,
+  restoreTokenSelectionStep,
+  runRecoveryRefetch,
+  runRestoreAuthorize,
+  runRestoreConnectWallet,
+  runRestoreDiscover,
+  runRestoreFetch,
+} from './restore/restoreEffects.js'
+export {
+  assertTokenNotInVault,
+  OperatorVaultUnavailableError,
+  TokenInVaultError,
+} from './vault/preflight.js'
+export {
+  createContinuityEnvelopeForSave,
+  expectedAccountForSnapshotSave,
+  snapshotSaveRequiresOwnerSigner,
+  snapshotSaveWalletRole,
+} from './shared/snapshot.js'
+export {
+  runCreatePreflight,
+  runCreateSigning,
+  runRegistrySubmit,
+  runStorageSubmit,
+} from './create.js'
+export {
+  runFixRecordsSubmit,
+  runRestoreRegistrySubmit,
+} from './restoreAdmin.js'
+export {
+  runPublicProfilePreflight,
+  runPublicProfileSigning,
+  runPublicProfileStorageSubmit,
+} from './publicProfile/runPublicProfileSave.js'
+export {
+  runRebackupPreflight,
+  runRebackupSigning,
+  runRebackupSigningInSession,
+  runRebackupStorageSubmit,
+} from './rebackup/runRebackup.js'
+export {
+  tokenTransferProgressForPhase,
+  runTokenTransferSigning,
+  runTokenTransferStorageSubmit,
+  runTokenTransferTargetSubmit,
+} from './token-transfer/runTokenTransfer.js'

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

@@ -0,0 +1,173 @@
+import { getAddress, isAddress, type Address } from 'viem'
+import type { EthagentIdentity } from '../../../../storage/config.js'
+import type { Erc8004RegistryConfig } from '../../../registry/erc8004.js'
+import { validateAgentEnsLink, type EnsValidation } from '../../../ens/ensLookup.js'
+import { clearOwnerAddressField, clearOperatorVaultAddressField, readOwnerAddressField, setOperatorVaultAddressField, setOwnerAddressField } from '../../../identityCompat.js'
+import { validateAdvancedEnsRelationship } from '../../advancedEnsValidation.js'
+import { readCustodyMode } from '../../model/custody.js'
+import { ensValidationReasonText } from '../../model/ens.js'
+import type { ProfileUpdates } from '../../identityHubReducer.js'
+import {
+  assertActiveOperatorIsApproved,
+  mergeApprovedOperatorWallets,
+  normalizeApprovedOperatorWallets,
+  upsertApprovedOperatorWallet,
+} from '../../operatorWallets.js'
+function ensValidationToState(validation: EnsValidation): Record<string, unknown> {
+  const checkedAt = new Date().toISOString()
+  if (validation.ok) {
+    return { ok: true, resolvedAddress: validation.resolvedAddress, checkedAt }
+  }
+  return {
+    ok: false,
+    reason: validation.reason,
+    ...(validation.detail ? { detail: validation.detail } : {}),
+    checkedAt,
+  }
+}
+
+export async function validateEnsForProfileUpdate(
+  fullName: string,
+  walletAccount: Address,
+  profile: ProfileUpdates,
+  baseState: Record<string, unknown>,
+  identity: EthagentIdentity,
+  registry: Erc8004RegistryConfig,
+): Promise<EnsValidation> {
+  const mode = readCustodyModeForUpdate(profile, baseState)
+  if (mode === 'advanced') {
+    const ownerAddress = readOwnerAddressForUpdate(profile, baseState)
+    if (!ownerAddress) {
+      return { ok: false, reason: 'lookup-failed', detail: 'no owner address recorded for advanced custody' }
+    }
+    const validation = await validateAdvancedEnsRelationship({
+      fullName,
+      ownerAddress: getAddress(ownerAddress),
+      registry,
+      agentId: identity.agentId,
+    })
+    return validation
+  }
+  return validateAgentEnsLink(fullName, walletAccount)
+}
+
+export function applyEnsValidationState(
+  state: Record<string, unknown>,
+  validation: EnsValidation,
+  profile: ProfileUpdates,
+  baseState: Record<string, unknown>,
+): void {
+  state.ensValidation = ensValidationToState(validation)
+  if (!validation.ok) {
+    throw new Error(`${ensValidationReasonText(validation.reason)}${validation.detail ? `: ${validation.detail}` : ''}`)
+  }
+  const mode = readCustodyModeForUpdate(profile, baseState)
+  state.custodyMode = mode
+  delete state.ensMode
+  if (mode === 'advanced') {
+    const ownerAddressValue = readOwnerAddressForUpdate(profile, baseState)
+    const operatorWallet = readActiveOperatorForUpdate(profile, baseState)
+    if (!ownerAddressValue || !operatorWallet) {
+      throw new Error('Advanced custody requires owner wallet and operator wallet addresses')
+    }
+    const ownerAddress = getAddress(ownerAddressValue)
+    const existingOperators = mergeApprovedOperatorWallets(baseState.approvedOperatorWallets, profile.approvedOperatorWallets ?? [], { walletAddress: ownerAddress })
+    const approvedOperatorWallets = upsertApprovedOperatorWallet(existingOperators, getAddress(operatorWallet), { walletAddress: ownerAddress })
+    setOwnerAddressField(state, getAddress(ownerAddress))
+    state.approvedOperatorWallets = approvedOperatorWallets
+    state.activeOperatorAddress = getAddress(operatorWallet)
+    return
+  }
+  clearOwnerAddressField(state)
+  delete state.approvedOperatorWallets
+  delete state.activeOperatorAddress
+}
+
+export function applyOperatorProfileState(
+  state: Record<string, unknown>,
+  profile: ProfileUpdates,
+  baseState: Record<string, unknown>,
+): void {
+  const operatorFieldsTouched = profile.custodyMode !== undefined
+    || profile.ownerAddress !== undefined
+    || profile.approvedOperatorWallets !== undefined
+    || profile.activeOperatorAddress !== undefined
+    || profile.operatorVaultAddress !== undefined
+    || profile.restoreAccessEpoch !== undefined
+  if (!operatorFieldsTouched) return
+
+  if (profile.custodyMode === 'simple') {
+    state.custodyMode = 'simple'
+    delete state.ensMode
+    clearOwnerAddressField(state)
+    delete state.approvedOperatorWallets
+    delete state.activeOperatorAddress
+    if (profile.restoreAccessEpoch !== undefined) {
+      state.restoreAccessEpoch = profile.restoreAccessEpoch
+    }
+    return
+  }
+  if (profile.custodyMode === 'advanced') {
+    state.custodyMode = 'advanced'
+    delete state.ensMode
+  }
+
+  if (profile.operatorVaultAddress !== undefined) {
+    if (typeof profile.operatorVaultAddress === 'string' && profile.operatorVaultAddress.trim()) {
+      setOperatorVaultAddressField(state, getAddress(profile.operatorVaultAddress))
+    } else {
+      clearOperatorVaultAddressField(state)
+    }
+  }
+
+  if (typeof profile.ownerAddress === 'string' && profile.ownerAddress.trim()) {
+    setOwnerAddressField(state, getAddress(profile.ownerAddress))
+  }
+
+  const approvedOperatorWallets = profile.approvedOperatorWallets !== undefined
+    ? normalizeApprovedOperatorWallets(profile.approvedOperatorWallets)
+    : normalizeApprovedOperatorWallets(baseState.approvedOperatorWallets)
+  if (profile.approvedOperatorWallets !== undefined) {
+    const ownerForCheck = readOwnerAddressField(state) ?? readOwnerAddressField(baseState) ?? ''
+    if (ownerForCheck && isAddress(ownerForCheck, { strict: false })) {
+      const ownerLower = ownerForCheck.toLowerCase()
+      if (approvedOperatorWallets.some(record => record.address.toLowerCase() === ownerLower)) {
+        throw new Error('Operator wallet must be different from the owner wallet')
+      }
+    }
+    state.approvedOperatorWallets = approvedOperatorWallets
+  }
+
+  const active = profile.activeOperatorAddress !== undefined
+    ? assertActiveOperatorIsApproved(approvedOperatorWallets, profile.activeOperatorAddress)
+    : assertActiveOperatorIsApproved(approvedOperatorWallets, readActiveOperatorForUpdate({}, baseState))
+  if (active) {
+    state.activeOperatorAddress = active
+  } else if (profile.activeOperatorAddress !== undefined) {
+    delete state.activeOperatorAddress
+  }
+  if (profile.restoreAccessEpoch !== undefined) {
+    state.restoreAccessEpoch = profile.restoreAccessEpoch
+  }
+}
+
+function readCustodyModeForUpdate(profile: ProfileUpdates, baseState: Record<string, unknown>): 'simple' | 'advanced' {
+  if (profile.custodyMode === 'simple' || profile.custodyMode === 'advanced') return profile.custodyMode
+  return readCustodyMode(baseState) ?? 'simple'
+}
+
+function readOwnerAddressForUpdate(profile: ProfileUpdates, baseState: Record<string, unknown>): string | undefined {
+  if (typeof profile.ownerAddress === 'string' && profile.ownerAddress.trim()) return profile.ownerAddress.trim()
+  return readOwnerAddressField(baseState)
+}
+
+function readActiveOperatorForUpdate(profile: ProfileUpdates, baseState: Record<string, unknown>): string | undefined {
+  if (typeof profile.activeOperatorAddress === 'string' && profile.activeOperatorAddress.trim()) return profile.activeOperatorAddress.trim()
+  const profileApproved = normalizeApprovedOperatorWallets(profile.approvedOperatorWallets)
+  if (profileApproved[0]) return profileApproved[0].address
+  const storedActive = baseState.activeOperatorAddress
+  if (typeof storedActive === 'string' && storedActive.trim()) return storedActive.trim()
+  const storedApproved = normalizeApprovedOperatorWallets(baseState.approvedOperatorWallets)
+  if (storedApproved[0]) return storedApproved[0].address
+  return undefined
+}

package/src/identity/hub/effects/publicProfile/index.ts

@@ -0,0 +1,5 @@
+export {
+  runPublicProfilePreflight,
+  runPublicProfileSigning,
+  runPublicProfileStorageSubmit,
+} from './runPublicProfileSave.js'