ethagent 1.1.1 → 2.0.0

package/src/identity/hub/useIdentityHubController.ts

@@ -0,0 +1,396 @@
+import { useEffect, useReducer, useState } from 'react'
+import type { EthagentConfig, EthagentIdentity } from '../../storage/config.js'
+import { defaultModelFor } from '../../storage/config.js'
+import { setTokenIdentity } from '../../storage/identity.js'
+import type { BrowserWalletReady } from '../wallet/browserWallet.js'
+import { registryConfigFromConfig } from '../registry/registryConfig.js'
+import type { Erc8004RegistryConfig } from '../registry/erc8004.js'
+import {
+  hasPinataJwt,
+} from '../storage/pinataJwt.js'
+import {
+  assertTokenNotInVault,
+  TokenInVaultError,
+} from './effects/vault/preflight.js'
+import {
+  runPublicProfilePreflight,
+} from './effects/publicProfile/runPublicProfileSave.js'
+import {
+  runRebackupPreflight,
+} from './effects/rebackup/runRebackup.js'
+import type {
+  EffectCallbacks,
+  IdentityCompletionSource,
+  RestoreProgress,
+  TokenTransferProgress,
+} from './effects/types.js'
+import { resolveOperatorVaultAddress } from './flows/custody/custodyEffects.js'
+import { useCustodyFlow } from './flows/custody/useCustodyFlow.js'
+import { identityHubErrorView } from './model/errors.js'
+import { readCustodyMode } from './model/custody.js'
+import { selectEnsStatus } from './model/ens.js'
+import { identityHubReducer, type ProfileUpdates, type Step } from './identityHubReducer.js'
+import type { IdentityHubProps } from './types.js'
+import {
+  capitalizeFeedbackMessage,
+  initialStepForAction,
+  isWalletCancelled,
+} from './utils.js'
+import {
+  preflightTokenOwnership,
+  useAgentReconciliation,
+} from './reconciliation/index.js'
+import { useIdentityHubContinuity } from './useIdentityHubContinuity.js'
+import { useIdentityHubSideEffects } from './useIdentityHubSideEffects.js'
+
+export function useIdentityHubController({
+  mode,
+  config,
+  initialAction,
+  onComplete,
+  onConfigChange,
+}: IdentityHubProps) {
+  const [firstRunIdentity, setFirstRunIdentity] = useState<EthagentIdentity | null>(null)
+  const identity = config?.identity ?? firstRunIdentity ?? undefined
+  const { reconciliation, refresh: refreshReconciliation } = useAgentReconciliation(config ?? null)
+  const [step, dispatch] = useReducer(identityHubReducer, initialStepForAction(initialAction, config))
+  const [walletSession, setWalletSession] = useState<BrowserWalletReady | null>(null)
+  const [restoreProgress, setRestoreProgress] = useState<RestoreProgress | null>(null)
+  const [tokenTransferProgress, setTokenTransferProgress] = useState<TokenTransferProgress | null>(null)
+  const [jwtSaved, setJwtSaved] = useState<boolean>(false)
+  const [copyNotice, setCopyNotice] = useState<string | null>(null)
+  const canRebackup = Boolean(identity?.agentId && (identity?.identityRegistryAddress || config?.erc8004?.identityRegistryAddress))
+
+  const setStep = (s: Step) => dispatch({ type: 'setStep', step: s })
+  const back = () => dispatch({ type: 'back', from: step })
+  const closeHub = () => onComplete(mode === 'first-run' ? { kind: 'skip' } : { kind: 'cancel' })
+
+  useEffect(() => { setWalletSession(null) }, [step.kind])
+  useEffect(() => {
+    if (step.kind !== 'restore-authorizing') setRestoreProgress(null)
+  }, [step.kind])
+  useEffect(() => {
+    if (step.kind !== 'token-transfer-signing') setTokenTransferProgress(null)
+  }, [step.kind])
+
+  useEffect(() => {
+    let cancelled = false
+    hasPinataJwt().then(v => { if (!cancelled) setJwtSaved(v) }).catch(() => {})
+    return () => { cancelled = true }
+  }, [step.kind])
+
+  useEffect(() => { setCopyNotice(null) }, [step.kind])
+  useEffect(() => {
+    if (!copyNotice) return
+    const timer = setTimeout(() => setCopyNotice(null), 2500)
+    return () => clearTimeout(timer)
+  }, [copyNotice])
+
+  const registryFromIdentity = (nextIdentity: EthagentIdentity): Erc8004RegistryConfig | null => {
+    if (!nextIdentity.chainId || !nextIdentity.identityRegistryAddress) return null
+    return {
+      chainId: nextIdentity.chainId,
+      rpcUrl: nextIdentity.rpcUrl ?? '',
+      identityRegistryAddress: nextIdentity.identityRegistryAddress as `0x${string}`,
+    }
+  }
+
+  const resolveRegistryForIdentity = (target: EthagentIdentity): Erc8004RegistryConfig | null => {
+    const resolution = registryConfigFromConfig(config)
+    if (target.chainId && target.identityRegistryAddress) {
+      return {
+        chainId: target.chainId,
+        rpcUrl: target.rpcUrl ?? resolution.defaultRpcUrl,
+        identityRegistryAddress: target.identityRegistryAddress as `0x${string}`,
+      }
+    }
+    if (resolution.config) return resolution.config
+    return null
+  }
+
+  const completeTokenIdentity = async (nextIdentity: EthagentIdentity, message: string, source?: IdentityCompletionSource): Promise<void> => {
+    if (mode === 'first-run' || !config) {
+      setFirstRunIdentity(nextIdentity)
+      const registry = registryFromIdentity(nextIdentity)
+      const custodyMode = readCustodyMode(nextIdentity.state)
+
+      if (source === 'create' && custodyMode === 'advanced' && registry) {
+        const seedConfig: EthagentConfig = {
+          version: 1,
+          provider: 'llamacpp',
+          model: defaultModelFor('llamacpp'),
+          firstRunAt: new Date().toISOString(),
+          identity: { ...nextIdentity, source: 'erc8004' },
+          erc8004: {
+            chainId: registry.chainId,
+            rpcUrl: registry.rpcUrl,
+            identityRegistryAddress: registry.identityRegistryAddress,
+          },
+        }
+        const persisted = await setTokenIdentity(seedConfig, nextIdentity)
+        onConfigChange?.(persisted)
+        const ownerAddress = (nextIdentity.ownerAddress ?? nextIdentity.address) as `0x${string}`
+        const profileUpdates: ProfileUpdates = {
+          custodyMode: 'advanced',
+          ownerAddress: ownerAddress,
+          bumpRestoreAccessEpoch: true,
+          custodyPhase: 'switch-advanced',
+        }
+        setStep({
+          kind: 'custody-vault-deploy-tx',
+          identity: nextIdentity,
+          registry,
+          profileUpdates,
+          returnTo: { kind: 'menu' },
+        })
+        return
+      }
+
+      const ensStatus = selectEnsStatus(nextIdentity)
+      if (registry && ensStatus.kind === 'none') {
+        setStep({ kind: 'first-run-ens-prompt', identity: nextIdentity, registry })
+        return
+      }
+      onComplete({ kind: 'token', identity: nextIdentity })
+      return
+    }
+    const nextConfig = await setTokenIdentity(config, nextIdentity)
+    const switchPhase = step.kind === 'rebackup-signing' || step.kind === 'rebackup-storage'
+      ? step.profileUpdates?.custodyPhase
+      : undefined
+    if (switchPhase === 'switch-advanced' || switchPhase === 'switch-simple') {
+      onConfigChange?.(nextConfig)
+      const registry = resolveRegistryForIdentity(nextIdentity)
+      if (registry) {
+        const vaultAddress = step.kind === 'rebackup-signing' || step.kind === 'rebackup-storage'
+          ? step.vaultAddress
+          : undefined
+        if (switchPhase === 'switch-advanced') {
+          setStep({
+            kind: 'custody-advanced-done',
+            identity: nextIdentity,
+            registry,
+            ...(vaultAddress ? { vaultAddress } : {}),
+            returnTo: { kind: 'menu' },
+          })
+        } else {
+          setStep({
+            kind: 'custody-simple-done',
+            identity: nextIdentity,
+            registry,
+            returnTo: { kind: 'menu' },
+          })
+        }
+        return
+      }
+    }
+    onComplete({ kind: 'updated', config: nextConfig, message: capitalizeFeedbackMessage(message) })
+  }
+
+  const callbacks: EffectCallbacks = {
+    onStep: setStep,
+    onWalletReady: setWalletSession,
+    onIdentityComplete: completeTokenIdentity,
+    onRestoreProgress: setRestoreProgress,
+    onTokenTransferProgress: setTokenTransferProgress,
+  }
+
+  const handleStepError = (err: unknown, backStep: Step, softCancel: Step = backStep): void => {
+    if (isWalletCancelled(err)) {
+      setStep(softCancel)
+      return
+    }
+    setStep({ kind: 'error', error: identityHubErrorView(err), back: backStep })
+  }
+
+  const guardOwnership = async (
+    target: EthagentIdentity,
+    registry: Erc8004RegistryConfig,
+    requiredRole: 'token-holder' | 'vault-level-owner',
+    backStep: Step,
+  ): Promise<boolean> => {
+    const result = await preflightTokenOwnership({
+      identity: target,
+      registry,
+      operatorVaults: config?.erc8004?.operatorVaults,
+      requiredRole,
+    })
+    if (result.ok) return true
+    if (result.reason === 'lookup-failed') {
+      return true
+    }
+    setStep({
+      kind: 'identity-unlinked',
+      identity: target,
+      registry,
+      ...(result.onChainOwner ? { onChainOwner: result.onChainOwner } : {}),
+      back: backStep,
+    })
+    return false
+  }
+
+  const triggerRebackup = (
+    backStep: Step,
+    profileUpdates?: ProfileUpdates,
+    options?: { vaultAddress?: `0x${string}`; useVault?: boolean },
+  ): void => {
+    if (!identity) return
+    const registry = resolveRegistryForIdentity(identity)
+    if (!registry) {
+      handleStepError(new Error('no agent registry configured for this identity'), backStep)
+      return
+    }
+    const vaultAddress = options?.useVault === false
+      ? undefined
+      : options?.vaultAddress ?? resolveOperatorVaultAddress(identity, config?.erc8004?.operatorVaults)
+    ;(async () => {
+      const role: 'token-holder' | 'vault-level-owner' = vaultAddress ? 'vault-level-owner' : 'token-holder'
+      const allowed = await guardOwnership(identity, registry, role, backStep)
+      if (!allowed) return
+      runRebackupPreflight(identity, registry, callbacks, profileUpdates, backStep, undefined, vaultAddress)
+        .catch((err: unknown) => handleStepError(err, backStep))
+    })()
+  }
+
+  const triggerPublicProfileSave = (backStep: Step, profileUpdates: ProfileUpdates): void => {
+    if (!identity) return
+    const registry = resolveRegistryForIdentity(identity)
+    if (!registry) {
+      handleStepError(new Error('no agent registry configured for this identity'), backStep)
+      return
+    }
+    ;(async () => {
+      const vaultAddress = resolveOperatorVaultAddress(identity, config?.erc8004?.operatorVaults)
+      const allowed = await guardOwnership(identity, registry, 'vault-level-owner', backStep)
+      if (!allowed) return
+      runPublicProfilePreflight(identity, registry, callbacks, profileUpdates, backStep, vaultAddress)
+        .catch((err: unknown) => handleStepError(err, backStep))
+    })()
+  }
+
+  const custodyFlow = useCustodyFlow({
+    config,
+    step,
+    setStep,
+    callbacks,
+    walletSession,
+    handleStepError,
+    guardOwnership,
+    triggerRebackup,
+    refreshReconciliation,
+    ...(onConfigChange ? { onConfigChange } : {}),
+  })
+
+  const continuity = useIdentityHubContinuity({
+    identity,
+    step,
+    setStep,
+    handleStepError,
+  })
+
+  useIdentityHubSideEffects({
+    step,
+    config,
+    callbacks,
+    setStep,
+    handleStepError,
+    triggerRebackup,
+    setContinuityReady: continuity.setContinuityReady,
+    ...(onConfigChange ? { onConfigChange } : {}),
+  })
+
+  const finishFirstRunIdentity = (): void => {
+    if (!firstRunIdentity) {
+      onComplete({ kind: 'skip' })
+      return
+    }
+    onComplete({ kind: 'token', identity: firstRunIdentity })
+  }
+
+  const openEnsEdit = (backStep: Step): void => {
+    if (!identity) return
+    if (!identity.agentId) {
+      handleStepError(new Error('Create an agent first to link an ENS name.'), backStep)
+      return
+    }
+    const registry = resolveRegistryForIdentity(identity)
+    if (!registry) {
+      handleStepError(new Error('no agent registry configured for this identity'), backStep)
+      return
+    }
+    setStep({ kind: 'edit-profile-ens', identity, registry, returnTo: backStep })
+  }
+
+  const openPublicProfileEdit = (backStep: Step): void => {
+    if (!identity) return
+    const registry = resolveRegistryForIdentity(identity)
+    if (!registry) {
+      handleStepError(new Error('no agent registry configured for this identity'), backStep)
+      return
+    }
+    setStep({ kind: 'edit-profile-name', identity, registry, returnTo: backStep })
+  }
+
+  const openTokenTransferFlow = async (): Promise<void> => {
+    if (!identity) return
+    if (!identity.agentId) {
+      handleStepError(new Error('Create an agent first to prepare a token transfer.'), { kind: 'menu' })
+      return
+    }
+    const registry = resolveRegistryForIdentity(identity)
+    if (!registry) {
+      handleStepError(new Error('no agent registry configured for this identity'), { kind: 'menu' })
+      return
+    }
+    setStep({ kind: 'busy', label: 'Checking token custody...' })
+    try {
+      await assertTokenNotInVault({ identity, registry, operatorVaults: config?.erc8004?.operatorVaults })
+    } catch (err: unknown) {
+      if (err instanceof TokenInVaultError) {
+        setStep({ kind: 'custody-model', identity, registry, returnTo: { kind: 'menu' }, notice: err.message })
+        return
+      }
+      handleStepError(err, { kind: 'menu' })
+      return
+    }
+    setStep({ kind: 'token-transfer-target', identity, registry })
+  }
+
+  return {
+    mode,
+    config,
+    onComplete,
+    onConfigChange,
+    identity,
+    reconciliation,
+    step,
+    walletSession,
+    restoreProgress,
+    tokenTransferProgress,
+    jwtSaved,
+    copyNotice,
+    canRebackup,
+    callbacks,
+    custodyFlow,
+    continuityReady: continuity.continuityReady,
+    workingStatus: continuity.workingStatus,
+    setStep,
+    back,
+    closeHub,
+    setWalletSession,
+    setJwtSaved,
+    setCopyNotice,
+    handleStepError,
+    resolveRegistryForIdentity,
+    triggerRebackup,
+    triggerPublicProfileSave,
+    finishFirstRunIdentity,
+    openEnsEdit,
+    openTokenTransferFlow,
+    openPublicProfileEdit,
+    openContinuityFile: continuity.openContinuityFile,
+    exportLocalBackupZip: continuity.exportLocalBackupZip,
+  }
+}
+
+export type IdentityHubController = ReturnType<typeof useIdentityHubController>

package/src/identity/hub/useIdentityHubSideEffects.ts

@@ -0,0 +1,309 @@
+import { useEffect } from 'react'
+import type { EthagentConfig } from '../../storage/config.js'
+import { setTokenIdentity } from '../../storage/identity.js'
+import { isRegistrationPreflightError, pinataErrorText } from './model/errors.js'
+import type { ProfileUpdates, Step } from './identityHubReducer.js'
+import {
+  runCreatePreflight,
+  runCreateSigning,
+} from './effects/create.js'
+import {
+  runRebackupSigning,
+} from './effects/rebackup/runRebackup.js'
+import {
+  runPublicProfileSigning,
+} from './effects/publicProfile/runPublicProfileSave.js'
+import {
+  runTokenTransferSigning,
+} from './effects/token-transfer/runTokenTransfer.js'
+import {
+  runEnsSetupRecordsTransaction,
+  runEnsSetupRegistryTransaction,
+  runUpdateEnsRecords,
+} from './effects/ens/index.js'
+import {
+  runRecoveryRefetch,
+} from './effects/restore/index.js'
+import type { EffectCallbacks } from './effects/types.js'
+import { useRestoreFlowEffects } from './flows/restore/useRestoreFlowEffects.js'
+import {
+  isStorageError,
+  isWalletCancelled,
+  waitForMinimumBusyTime,
+} from './utils.js'
+
+type TriggerRebackup = (
+  backStep: Step,
+  profileUpdates?: ProfileUpdates,
+  options?: { vaultAddress?: `0x${string}`; useVault?: boolean },
+) => void
+
+type UseIdentityHubSideEffectsArgs = {
+  step: Step
+  config: EthagentConfig | undefined
+  callbacks: EffectCallbacks
+  setStep: (step: Step) => void
+  handleStepError: (err: unknown, backStep: Step, softCancel?: Step) => void
+  triggerRebackup: TriggerRebackup
+  setContinuityReady: (ready: boolean) => void
+  onConfigChange?: (config: EthagentConfig) => void
+}
+
+export function useIdentityHubSideEffects({
+  step,
+  config,
+  callbacks,
+  setStep,
+  handleStepError,
+  triggerRebackup,
+  setContinuityReady,
+  onConfigChange,
+}: UseIdentityHubSideEffectsArgs): void {
+  useEffect(() => {
+    if (step.kind !== 'rebackup-start') return
+    triggerRebackup(step.back)
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'create-preflight') return
+    let cancelled = false
+    const startedAt = Date.now()
+    runCreatePreflight(step, config, callbacks)
+      .catch(async (err: unknown) => {
+        await waitForMinimumBusyTime(startedAt)
+        if (!cancelled) handleStepError(err, { kind: 'create-network', name: step.name, description: step.description })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'create-signing') return
+    let cancelled = false
+    const backStep: Step = { kind: 'create-network', name: step.name, description: step.description }
+    runCreateSigning(step, callbacks)
+      .catch((err: unknown) => {
+        if (cancelled) return
+        if (isRegistrationPreflightError(err)) {
+          handleStepError(err, backStep)
+          return
+        }
+        if (isStorageError(err)) {
+          setStep({
+            kind: 'create-storage',
+            name: step.name,
+            description: step.description,
+            registry: step.registry,
+            custodyMode: step.custodyMode,
+            error: pinataErrorText(err),
+            pinataJwt: step.pinataJwt,
+          })
+          return
+        }
+        handleStepError(err, backStep)
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useRestoreFlowEffects({ step, config, callbacks, handleStepError })
+
+  useEffect(() => {
+    if (step.kind !== 'rebackup-signing') return
+    let cancelled = false
+    runRebackupSigning(step, callbacks)
+      .catch((err: unknown) => {
+        if (cancelled) return
+        if (isStorageError(err)) {
+          setStep({
+            kind: 'rebackup-storage',
+            identity: step.identity,
+            registry: step.registry,
+            error: pinataErrorText(err),
+            pinataJwt: step.pinataJwt,
+            profileUpdates: step.profileUpdates,
+            returnTo: step.returnTo,
+            walletPurpose: step.walletPurpose,
+          })
+          return
+        }
+        handleStepError(err, step.returnTo ?? { kind: 'menu' })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'public-profile-signing') return
+    let cancelled = false
+    runPublicProfileSigning(step, callbacks)
+      .catch((err: unknown) => {
+        if (cancelled) return
+        if (isStorageError(err)) {
+          setStep({
+            kind: 'public-profile-storage',
+            identity: step.identity,
+            registry: step.registry,
+            error: pinataErrorText(err),
+            pinataJwt: step.pinataJwt,
+            profileUpdates: step.profileUpdates,
+            returnTo: step.returnTo,
+            ...(step.vaultAddress ? { vaultAddress: step.vaultAddress } : {}),
+          })
+          return
+        }
+        handleStepError(err, step.returnTo ?? { kind: 'continuity-public' })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'token-transfer-signing') return
+    let cancelled = false
+    runTokenTransferSigning(step, callbacks)
+      .then(async result => {
+        if (cancelled) return
+        if (config) {
+          const nextConfig = await setTokenIdentity(config, result.identity)
+          onConfigChange?.(nextConfig)
+        }
+        setStep({
+          kind: 'token-transfer-ready',
+          identity: result.identity,
+          registry: step.registry,
+          targetHandle: step.targetHandle,
+          targetAddress: step.targetAddress,
+          snapshotCid: result.snapshotCid,
+          txHash: result.txHash,
+          returnTo: step.returnTo,
+        })
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        if (isStorageError(err)) {
+          setStep({
+            kind: 'token-transfer-storage',
+            identity: step.identity,
+            registry: step.registry,
+            targetHandle: step.targetHandle,
+            targetAddress: step.targetAddress,
+            error: pinataErrorText(err),
+            pinataJwt: step.pinataJwt,
+            returnTo: step.returnTo,
+          })
+          return
+        }
+        const message = err instanceof Error ? err.message : String(err)
+        const targetReturn: Step = {
+          kind: 'token-transfer-target',
+          identity: step.identity,
+          registry: step.registry,
+          previousTarget: step.targetHandle,
+          ...(step.returnTo ? { returnTo: step.returnTo } : {}),
+          ...(isWalletCancelled(err) ? {} : { error: message }),
+        }
+        if (isWalletCancelled(err)) {
+          setStep(targetReturn)
+          return
+        }
+        handleStepError(err, targetReturn)
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'recovery-refetching') return
+    let cancelled = false
+    runRecoveryRefetch(step.identity, step.registry, callbacks)
+      .then(() => {
+        if (!cancelled) setContinuityReady(true)
+      })
+      .catch((err: unknown) => {
+        if (!cancelled) handleStepError(err, { kind: 'menu' })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'ens-records-tx') return
+    let cancelled = false
+    const ownerAddress = (step.ownerAddress ?? step.identity.ownerAddress ?? step.identity.address) as `0x${string}`
+    runUpdateEnsRecords({
+      fullName: step.fullName,
+      ownerAddress,
+      records: step.records,
+      currentRecords: step.currentRecords,
+      callbacks,
+      clearRecords: step.clearRecords,
+      purpose: step.clearRecords ? 'clear-ens-records' : undefined,
+      tokenChainId: step.registry.chainId,
+    })
+      .then(() => {
+        if (cancelled) return
+        triggerRebackup(step.returnTo ?? { kind: 'menu' }, step.clearRecords ? { ensName: '' } : { ensName: step.fullName })
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        handleStepError(err, { kind: 'edit-profile-ens', identity: step.identity, registry: step.registry, returnTo: step.returnTo })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'ens-setup-registry-tx') return
+    let cancelled = false
+    runEnsSetupRegistryTransaction({ setup: step.setup, callbacks, tokenChainId: step.registry.chainId })
+      .then(result => {
+        if (cancelled) return
+        setStep({
+          kind: 'ens-setup-records-tx',
+          identity: step.identity,
+          registry: step.registry,
+          setup: step.setup,
+          returnTo: step.returnTo,
+          ...(result ? { registryTxHash: result.txHash } : {}),
+        })
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        handleStepError(err, {
+          kind: 'edit-profile-ens',
+          identity: step.identity,
+          registry: step.registry,
+          returnTo: step.returnTo,
+          ...(step.setup.mode === 'advanced' ? { initialView: 'advanced' as const } : {}),
+        })
+      })
+    return () => { cancelled = true }
+  }, [step])
+
+  useEffect(() => {
+    if (step.kind !== 'ens-setup-records-tx') return
+    let cancelled = false
+    runEnsSetupRecordsTransaction({ setup: step.setup, callbacks, tokenChainId: step.registry.chainId })
+      .then(() => {
+        if (cancelled) return
+        const ensUpdates = step.setup.mode === 'advanced'
+          ? {
+              ensName: step.setup.fullName,
+              custodyMode: 'advanced' as const,
+              ownerAddress: step.setup.ownerAddress,
+              approvedOperatorWallets: [step.setup.operatorAddress],
+              activeOperatorAddress: step.setup.operatorAddress,
+            }
+          : {
+              ensName: step.setup.fullName,
+              custodyMode: 'simple' as const,
+            }
+        triggerRebackup(step.returnTo ?? { kind: 'menu' }, ensUpdates)
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        handleStepError(err, {
+          kind: 'edit-profile-ens',
+          identity: step.identity,
+          registry: step.registry,
+          returnTo: step.returnTo,
+          ...(step.setup.mode === 'advanced' ? { initialView: 'advanced' as const } : {}),
+        })
+      })
+    return () => { cancelled = true }
+  }, [step])
+}