ethagent 1.1.1 → 2.0.0

package/src/identity/hub/components/menuFlagsFromReconciliation.ts

@@ -0,0 +1,68 @@
+import type { AgentReconciliation } from '../reconciliation/index.js'
+import type { IdentityPerspective } from '../model/custody.js'
+
+type MenuFlags = {
+  prepareTransferDisabled: boolean
+  prepareTransferReason?: string
+  custodyModeDisabled: boolean
+  custodyModeReason?: string
+  ensNameDisabled: boolean
+  ensNameReason?: string
+  saveSnapshotDisabled: boolean
+  refetchLatestDisabled: boolean
+  tokenValuesUnlinkedNote?: string
+
+  custodyAsterisk: boolean
+  custodyHint?: string
+  saveSnapshotAsterisk: boolean
+  saveSnapshotHint?: string
+}
+
+export function menuFlagsFromReconciliation(r: AgentReconciliation, perspective: IdentityPerspective = 'unknown'): MenuFlags {
+  const unlinked = r.token === 'unlinked'
+  const inVault = r.custody === 'advanced' || r.custody === 'mid-flow-uri-pending'
+  const isOperator = perspective === 'operator'
+
+  let prepareTransferReason: string | undefined
+  if (isOperator) {
+    prepareTransferReason = 'Operators cannot transfer the token.'
+  } else if (!unlinked && (r.custody === 'advanced' || r.custody === 'mid-flow-uri-pending')) {
+    prepareTransferReason = 'Token is in the vault. Withdraw it first in Custody Mode.'
+  }
+
+  const custodyAsterisk = r.custody === 'mid-flow-uri-pending' || r.ensRecords === 'drift' || r.vault === 'missing'
+  let custodyHint: string | undefined
+  if (isOperator) {
+    custodyHint = undefined
+  } else if (r.custody === 'mid-flow-uri-pending') {
+    custodyHint = 'Advanced setup pending. Open to finish.'
+  } else if (r.vault === 'missing') {
+    custodyHint = 'Vault contract not found. Open to redeploy.'
+  } else if (r.ensRecords === 'drift') {
+    custodyHint = 'ENS records out of sync. Open to fix.'
+  }
+
+  const custodyModeReason = isOperator
+    ? 'Operators cannot change custody, withdraw the token, or manage operators.'
+    : undefined
+  const ensNameReason = isOperator
+    ? 'Operators cannot change the ENS subdomain or its records.'
+    : undefined
+
+  return {
+    prepareTransferDisabled: unlinked || inVault || isOperator,
+    ...(prepareTransferReason ? { prepareTransferReason } : {}),
+    custodyModeDisabled: unlinked || isOperator,
+    ...(custodyModeReason ? { custodyModeReason } : {}),
+    ensNameDisabled: unlinked || isOperator,
+    ...(ensNameReason ? { ensNameReason } : {}),
+    saveSnapshotDisabled: unlinked,
+    refetchLatestDisabled: unlinked,
+    ...(unlinked ? { tokenValuesUnlinkedNote: 'Token no longer linked to this wallet, values retained for reference' } : {}),
+
+    custodyAsterisk: custodyAsterisk && !isOperator,
+    ...(custodyHint ? { custodyHint } : {}),
+    saveSnapshotAsterisk: r.agentUri === 'local-newer',
+    ...(r.agentUri === 'local-newer' ? { saveSnapshotHint: 'Local state newer than chain. Save to publish the latest agentURI.' } : {}),
+  }
+}

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

@@ -0,0 +1,310 @@
+import type { Address, Hex } from 'viem'
+import type { EthagentConfig, EthagentIdentity, SelectableNetwork } from '../../../storage/config.js'
+import { saveConfig } from '../../../storage/config.js'
+import {
+  createContinuitySnapshotChallenge,
+  createContinuitySnapshotEnvelope,
+  serializeContinuitySnapshotEnvelope,
+} from '../../continuity/envelope.js'
+import {
+  continuityAgentSnapshot,
+  defaultContinuityFiles,
+  writeIdentityMarkdownScaffold,
+} from '../../continuity/storage.js'
+import {
+  createAgentCard,
+  defaultPublicSkillsProfile,
+  renderPublicSkillsJson,
+  serializeAgentCard,
+} from '../../continuity/publicSkills.js'
+import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
+import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
+import {
+  chainIdForNetwork,
+  createErc8004PublicClient,
+  encodeRegisterAgent,
+  erc8004ConfigForSupportedChain,
+  normalizeErc8004RegistryConfig,
+  preflightRegisterAgent,
+  registeredAgentFromReceipt,
+  withEthagentPointers,
+  type Erc8004RegistryConfig,
+} from '../../registry/erc8004.js'
+import { registryConfigFromConfig, type RegistryResolution } from '../../registry/registryConfig.js'
+import { resolveValidatedPinataJwt, savePinataJwt } from '../../storage/pinataJwt.js'
+import { setOwnerAddressField } from '../../identityCompat.js'
+import {
+  requestBrowserWalletSignatureAndTransaction,
+} from '../../wallet/browserWallet.js'
+import { initialAgentState, PREFLIGHT_AGENT_URI } from '../model/identity.js'
+import type { Step } from '../identityHubReducer.js'
+import type { EffectCallbacks } from './types.js'
+import { awaitConfirmedReceipt } from './receipts.js'
+import { assertVerifiedPin } from './shared/profilePrep.js'
+
+type BackupMetadata = NonNullable<EthagentIdentity['backup']>
+type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+
+type CreatePreparedTransaction = {
+  ownerAddress: Address
+  agentUri: string
+  metadataCid: string
+  backup: BackupMetadata
+  publicSkills: PublicSkillsMetadata
+  state: Record<string, unknown>
+  continuityFiles: ReturnType<typeof defaultContinuityFiles>
+  publicSkillsJson: string
+}
+
+export async function runCreatePreflight(
+  step: Extract<Step, { kind: 'create-preflight' }>,
+  config: EthagentConfig | undefined,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  const resolution = step.network
+    ? registryResolutionForNetwork(step.network)
+    : registryConfigFromConfig(config)
+  if (!resolution.config) {
+    callbacks.onStep({ kind: 'create-registry', name: step.name, description: step.description, resolution, custodyMode: step.custodyMode })
+    return
+  }
+  const apiUrl = DEFAULT_IPFS_API_URL
+  let jwt: string | undefined
+  try {
+    jwt = isPinataUploadUrl(apiUrl) ? await resolveValidatedPinataJwt() : undefined
+  } catch (err: unknown) {
+    callbacks.onStep({
+      kind: 'create-storage',
+      name: step.name,
+      description: step.description,
+      registry: resolution.config,
+      custodyMode: step.custodyMode,
+      error: (err as Error).message,
+    })
+    return
+  }
+  if (isPinataUploadUrl(apiUrl) && !jwt) {
+    callbacks.onStep({ kind: 'create-storage', name: step.name, description: step.description, registry: resolution.config, custodyMode: step.custodyMode })
+    return
+  }
+  callbacks.onStep({ kind: 'create-signing', name: step.name, description: step.description, registry: resolution.config, custodyMode: step.custodyMode, pinataJwt: jwt })
+}
+
+function registryResolutionForNetwork(network: SelectableNetwork): RegistryResolution {
+  const chainId = chainIdForNetwork(network)
+  try {
+    const registry = erc8004ConfigForSupportedChain(chainId)
+    return {
+      config: registry,
+      network,
+      chainId,
+      needsRegistryAddress: false,
+      defaultRpcUrl: registry.rpcUrl,
+    }
+  } catch {
+    return {
+      config: null,
+      network,
+      chainId,
+      needsRegistryAddress: true,
+      defaultRpcUrl: '',
+    }
+  }
+}
+
+export async function runCreateSigning(
+  step: Extract<Step, { kind: 'create-signing' }>,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  const result = await requestBrowserWalletSignatureAndTransaction<CreatePreparedTransaction>({
+    chainId: step.registry.chainId,
+    messageForAccount: account => createContinuitySnapshotChallenge(account),
+    onReady: callbacks.onWalletReady,
+    purpose: 'create-agent',
+    prepareTransaction: async wallet => {
+      await preflightRegisterAgent({
+        ...step.registry,
+        ownerAddress: wallet.account,
+        agentURI: PREFLIGHT_AGENT_URI,
+      })
+      const state = initialAgentState(step.name, step.description, wallet.account)
+      state.custodyMode = step.custodyMode
+      if (step.custodyMode === 'advanced') {
+        setOwnerAddressField(state, wallet.account)
+      }
+      const draftIdentity = identityDraftForBackup({
+        ownerAddress: wallet.account,
+        registry: step.registry,
+        state,
+      })
+      const continuityFiles = defaultContinuityFiles(draftIdentity)
+      const publicProfile = defaultPublicSkillsProfile(draftIdentity)
+      const publicSkillsJson = renderPublicSkillsJson(publicProfile)
+      const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
+      assertVerifiedPin(publicSkillsPin)
+      const agentCardPin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeAgentCard(createAgentCard(publicProfile)), fetch, { pinataJwt: step.pinataJwt })
+      assertVerifiedPin(agentCardPin)
+      const envelope = createContinuitySnapshotEnvelope({
+        ownerAddress: wallet.account,
+        walletSignature: wallet.signature,
+        payload: {
+          agent: continuityAgentSnapshot(draftIdentity),
+          files: continuityFiles,
+          transcript: [],
+          state,
+        },
+      })
+      const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
+      assertVerifiedPin(statePin)
+      const cid = statePin.cid
+      const backup: BackupMetadata = {
+        cid,
+        createdAt: envelope.createdAt,
+        envelopeVersion: envelope.envelopeVersion,
+        ipfsApiUrl: DEFAULT_IPFS_API_URL,
+        status: 'pinned',
+        ownerAddress: wallet.account,
+        chainId: step.registry.chainId,
+        rpcUrl: step.registry.rpcUrl,
+        identityRegistryAddress: step.registry.identityRegistryAddress,
+      }
+      const publicSkills: PublicSkillsMetadata = {
+        cid: publicSkillsPin.cid,
+        agentCardCid: agentCardPin.cid,
+        updatedAt: envelope.createdAt,
+        status: 'pinned',
+      }
+      const registration = withEthagentPointers({
+        type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
+        name: step.name,
+        ...(step.description ? { description: step.description } : {}),
+        ...(typeof state.imageUrl === 'string' ? { image: state.imageUrl } : {}),
+      }, {
+        backup: { cid, envelopeVersion: envelope.envelopeVersion, createdAt: envelope.createdAt },
+        publicDiscovery: { skillsCid: publicSkills.cid, agentCardCid: publicSkills.agentCardCid, updatedAt: publicSkills.updatedAt },
+        registration: { chainId: step.registry.chainId, identityRegistryAddress: step.registry.identityRegistryAddress },
+        ownerAddress: wallet.account,
+      })
+      const metadataPin = await addToIpfs(DEFAULT_IPFS_API_URL, JSON.stringify(registration, null, 2), fetch, { pinataJwt: step.pinataJwt })
+      assertVerifiedPin(metadataPin)
+      const metadataCid = metadataPin.cid
+      const agentUri = `ipfs://${metadataCid}`
+      return {
+        to: step.registry.identityRegistryAddress,
+        data: encodeRegisterAgent({ agentURI: agentUri }),
+        prepared: {
+          ownerAddress: wallet.account,
+          agentUri,
+          metadataCid,
+          backup: { ...backup, metadataCid, agentUri },
+          publicSkills,
+          state,
+          continuityFiles,
+          publicSkillsJson,
+        },
+      }
+    },
+  })
+  const client = createErc8004PublicClient(step.registry)
+  const receipt = await awaitConfirmedReceipt(client, result.txHash, 'Agent registration', { kind: 'register', chainId: step.registry.chainId })
+  const registered = registeredAgentFromReceipt({
+    logs: receipt.logs.map(log => ({ address: log.address, topics: [...log.topics] as Hex[], data: log.data })),
+    identityRegistryAddress: step.registry.identityRegistryAddress,
+    ownerAddress: result.prepared.ownerAddress,
+    fallbackAgentURI: result.prepared.agentUri,
+  })
+  const backup: BackupMetadata = {
+    ...result.prepared.backup,
+    agentId: registered.agentId.toString(),
+    agentUri: registered.agentURI,
+    txHash: result.txHash,
+  }
+  const nextIdentity: EthagentIdentity = {
+    source: 'erc8004',
+    address: result.prepared.ownerAddress,
+    ownerAddress: result.prepared.ownerAddress,
+    connectedWallet: result.prepared.ownerAddress,
+    createdAt: result.prepared.backup.createdAt,
+    chainId: step.registry.chainId,
+    rpcUrl: step.registry.rpcUrl,
+    identityRegistryAddress: step.registry.identityRegistryAddress,
+    agentId: registered.agentId.toString(),
+    agentUri: registered.agentURI,
+    metadataCid: result.prepared.metadataCid,
+    state: result.prepared.state,
+    backup,
+    publicSkills: result.prepared.publicSkills,
+  }
+  await writeIdentityMarkdownScaffold(nextIdentity, {
+    ...defaultContinuityFiles(nextIdentity),
+    'skills.json': result.prepared.publicSkillsJson,
+  })
+  await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'initial published snapshot' }).catch(() => null)
+  await callbacks.onIdentityComplete(nextIdentity, `ERC-8004 agent registered · #${registered.agentId.toString()}`, 'create')
+}
+
+export async function runRegistrySubmit(
+  value: string,
+  step: Extract<Step, { kind: 'create-registry' }>,
+  config: EthagentConfig | undefined,
+  onConfigChange: ((config: EthagentConfig) => void) | undefined,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  const registry = normalizeErc8004RegistryConfig({
+    chainId: step.resolution.chainId,
+    rpcUrl: step.resolution.defaultRpcUrl,
+    identityRegistryAddress: value.trim(),
+  })
+  if (config && onConfigChange) {
+    const next: EthagentConfig = {
+      ...config,
+      erc8004: {
+        chainId: registry.chainId,
+        rpcUrl: registry.rpcUrl,
+        identityRegistryAddress: registry.identityRegistryAddress,
+      },
+    }
+    await saveConfig(next)
+    onConfigChange(next)
+  }
+  const apiUrl = DEFAULT_IPFS_API_URL
+  let jwt: string | undefined
+  try {
+    jwt = isPinataUploadUrl(apiUrl) ? await resolveValidatedPinataJwt() : undefined
+  } catch (err: unknown) {
+    callbacks.onStep({ kind: 'create-storage', name: step.name, description: step.description, registry, custodyMode: step.custodyMode, error: (err as Error).message })
+    return
+  }
+  if (isPinataUploadUrl(apiUrl) && !jwt) {
+    callbacks.onStep({ kind: 'create-storage', name: step.name, description: step.description, registry, custodyMode: step.custodyMode })
+    return
+  }
+  callbacks.onStep({ kind: 'create-signing', name: step.name, description: step.description, registry, custodyMode: step.custodyMode, pinataJwt: jwt })
+}
+
+export async function runStorageSubmit(
+  input: string,
+  step: Extract<Step, { kind: 'create-storage' }>,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  const { jwt: pinataJwt } = await savePinataJwt(input)
+  callbacks.onStep({ kind: 'create-signing', name: step.name, description: step.description, registry: step.registry, custodyMode: step.custodyMode, pinataJwt })
+}
+
+function identityDraftForBackup(args: {
+  ownerAddress: Address
+  registry: Erc8004RegistryConfig
+  state: Record<string, unknown>
+}): EthagentIdentity {
+  return {
+    source: 'erc8004',
+    address: args.ownerAddress,
+    ownerAddress: args.ownerAddress,
+    createdAt: typeof args.state.createdAt === 'string' ? args.state.createdAt : new Date().toISOString(),
+    chainId: args.registry.chainId,
+    rpcUrl: args.registry.rpcUrl,
+    identityRegistryAddress: args.registry.identityRegistryAddress,
+    agentUri: PREFLIGHT_AGENT_URI,
+    state: args.state,
+  }
+}

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

@@ -0,0 +1,218 @@
+import type { Address, PublicClient } from 'viem'
+import type { EthagentIdentity } from '../../../../storage/config.js'
+import type { AgentEnsRecordState, AgentEnsRecords } from '../../../ens/agentRecords.js'
+import type { Erc8004RegistryConfig } from '../../../registry/erc8004.js'
+import {
+  openBrowserWalletSession,
+  type WalletPurpose,
+} from '../../../wallet/browserWallet.js'
+import type { ProfileUpdates, Step } from '../../identityHubReducer.js'
+import type { EffectCallbacks, EnsClearProgress, EnsLinkProgress, EnsUpdateProgress } from '../types.js'
+import {
+  runEnsSetupRecordsTransaction,
+  runEnsSetupRegistryTransaction,
+  runUpdateEnsRecords,
+} from './transactions.js'
+import { runRebackupSigningInSession } from '../rebackup/runRebackup.js'
+
+type EnsRecordsFlowArgs = {
+  identity: EthagentIdentity
+  registry: Erc8004RegistryConfig
+  fullName: string
+  ownerAddress: Address
+  records: AgentEnsRecords
+  currentRecords?: AgentEnsRecordState
+  pinataJwt?: string
+  publicClient?: PublicClient
+}
+
+async function runEnsRecordsThenSnapshot(args: {
+  flowId: 'ens-clear' | 'ens-update' | 'ens-link'
+  flow: EnsRecordsFlowArgs
+  clearRecords: boolean
+  recordsPurpose: WalletPurpose
+  callbacks: EffectCallbacks
+  reportProgress: (phase: 'records-tx' | 'records-confirming' | 'snapshot-sign' | 'snapshot-tx' | 'snapshot-confirming') => void
+  preRecordsSteps?: number
+  totalSteps: number
+}): Promise<void> {
+  const { flow } = args
+  const session = await openBrowserWalletSession({ onReady: args.callbacks.onWalletReady })
+  try {
+    args.reportProgress('records-tx')
+    const recordsStepIndex = (args.preRecordsSteps ?? 0) + 1
+    await runUpdateEnsRecords({
+      fullName: flow.fullName,
+      ownerAddress: flow.ownerAddress,
+      records: flow.records,
+      ...(flow.currentRecords ? { currentRecords: flow.currentRecords } : {}),
+      callbacks: args.callbacks,
+      purpose: args.recordsPurpose,
+      clearRecords: args.clearRecords,
+      ...(flow.publicClient ? { publicClient: flow.publicClient } : {}),
+      tokenChainId: flow.registry.chainId,
+      session,
+      flowId: args.flowId,
+      flowStep: recordsStepIndex,
+    })
+    args.reportProgress('records-confirming')
+    args.reportProgress('snapshot-sign')
+    const snapshotStepIndex = recordsStepIndex + 1
+    const nextEnsName = args.clearRecords ? '' : flow.fullName
+    const profileUpdates: ProfileUpdates = { ensName: nextEnsName }
+    const rebackupStep: Extract<Step, { kind: 'rebackup-signing' }> = {
+      kind: 'rebackup-signing',
+      identity: flow.identity,
+      registry: flow.registry,
+      profileUpdates,
+      ...(flow.pinataJwt ? { pinataJwt: flow.pinataJwt } : {}),
+    }
+    args.reportProgress('snapshot-tx')
+    await runRebackupSigningInSession(rebackupStep, args.callbacks, session, {
+      flowId: args.flowId,
+      flowStep: snapshotStepIndex,
+    })
+    args.reportProgress('snapshot-confirming')
+  } finally {
+    await session.close().catch(() => null)
+    args.callbacks.onWalletReady(null)
+  }
+}
+
+export async function runEnsUnlinkFlow(
+  step: Extract<Step, { kind: 'ens-clear-flow-running' }>,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  await runEnsRecordsThenSnapshot({
+    flowId: 'ens-clear',
+    clearRecords: true,
+    recordsPurpose: 'clear-ens-records',
+    flow: {
+      identity: step.identity,
+      registry: step.registry,
+      fullName: step.fullName,
+      ownerAddress: step.ownerAddress,
+      records: step.records,
+      ...(step.currentRecords ? { currentRecords: step.currentRecords } : {}),
+      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
+    },
+    callbacks,
+    reportProgress: phase => callbacks.onEnsClearProgress?.({ phase, label: ensClearLabelFor(phase) }),
+    totalSteps: 2,
+  })
+  callbacks.onEnsClearProgress?.(null)
+}
+
+export async function runEnsUpdateFlow(
+  step: Extract<Step, { kind: 'ens-update-flow-running' }>,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  await runEnsRecordsThenSnapshot({
+    flowId: 'ens-update',
+    clearRecords: false,
+    recordsPurpose: 'update-ens-records',
+    flow: {
+      identity: step.identity,
+      registry: step.registry,
+      fullName: step.fullName,
+      ownerAddress: step.ownerAddress,
+      records: step.records,
+      ...(step.currentRecords ? { currentRecords: step.currentRecords } : {}),
+      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
+    },
+    callbacks,
+    reportProgress: phase => callbacks.onEnsUpdateProgress?.({ phase, label: ensUpdateLabelFor(phase) }),
+    totalSteps: 2,
+  })
+  callbacks.onEnsUpdateProgress?.(null)
+}
+
+function ensClearLabelFor(phase: EnsClearProgress['phase']): string {
+  switch (phase) {
+    case 'records-tx': return 'Clearing ENS records on Ethereum Mainnet...'
+    case 'records-confirming': return 'Waiting for ENS clear confirmation...'
+    case 'snapshot-sign': return 'Sign to save the cleared snapshot...'
+    case 'snapshot-tx': return 'Publishing cleared snapshot to the agent token URI...'
+    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
+  }
+}
+
+function ensUpdateLabelFor(phase: EnsUpdateProgress['phase']): string {
+  switch (phase) {
+    case 'records-tx': return 'Updating ENS records on Ethereum Mainnet...'
+    case 'records-confirming': return 'Waiting for ENS records confirmation...'
+    case 'snapshot-sign': return 'Sign to save the updated snapshot...'
+    case 'snapshot-tx': return 'Publishing updated snapshot to the agent token URI...'
+    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
+  }
+}
+
+function ensLinkLabelFor(phase: EnsLinkProgress['phase']): string {
+  switch (phase) {
+    case 'registry-tx': return 'Creating ENS subdomain on Ethereum Mainnet...'
+    case 'registry-confirming': return 'Waiting for subdomain creation confirmation...'
+    case 'records-tx': return 'Setting ENS records on Ethereum Mainnet...'
+    case 'records-confirming': return 'Waiting for ENS records confirmation...'
+    case 'snapshot-sign': return 'Sign to save the linked snapshot...'
+    case 'snapshot-tx': return 'Publishing linked snapshot to the agent token URI...'
+    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
+  }
+}
+
+export async function runEnsLinkFlow(
+  step: Extract<Step, { kind: 'ens-link-flow-running' }>,
+  callbacks: EffectCallbacks,
+): Promise<void> {
+  const session = await openBrowserWalletSession({ onReady: callbacks.onWalletReady })
+  const report = (phase: EnsLinkProgress['phase']): void => {
+    callbacks.onEnsLinkProgress?.({ phase, label: ensLinkLabelFor(phase) })
+  }
+  try {
+    let stepIndex = 0
+    const willRunRegistry = step.setup.registryAction !== 'none'
+    if (willRunRegistry) {
+      stepIndex += 1
+      report('registry-tx')
+      await runEnsSetupRegistryTransaction({
+        setup: step.setup,
+        callbacks,
+        tokenChainId: step.registry.chainId,
+        session,
+        flowId: 'ens-link',
+        flowStep: stepIndex,
+      })
+      report('registry-confirming')
+    }
+    stepIndex += 1
+    report('records-tx')
+    await runEnsSetupRecordsTransaction({
+      setup: step.setup,
+      callbacks,
+      tokenChainId: step.registry.chainId,
+      session,
+      flowId: 'ens-link',
+      flowStep: stepIndex,
+    })
+    report('records-confirming')
+    stepIndex += 1
+    report('snapshot-sign')
+    const profileUpdates: ProfileUpdates = { ensName: step.setup.fullName }
+    const rebackupStep: Extract<Step, { kind: 'rebackup-signing' }> = {
+      kind: 'rebackup-signing',
+      identity: step.identity,
+      registry: step.registry,
+      profileUpdates,
+      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
+    }
+    report('snapshot-tx')
+    await runRebackupSigningInSession(rebackupStep, callbacks, session, {
+      flowId: 'ens-link',
+      flowStep: stepIndex,
+    })
+    report('snapshot-confirming')
+  } finally {
+    await session.close().catch(() => null)
+    callbacks.onWalletReady(null)
+    callbacks.onEnsLinkProgress?.(null)
+  }
+}

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

@@ -0,0 +1,11 @@
+export {
+  runEnsLinkFlow,
+  runEnsUnlinkFlow,
+  runEnsUpdateFlow,
+} from './flows.js'
+export {
+  ensRecordWritesForUpdate,
+  runEnsSetupRecordsTransaction,
+  runEnsSetupRegistryTransaction,
+  runUpdateEnsRecords,
+} from './transactions.js'