ethagent 2.1.1 → 2.2.0

package/src/identity/hub/reconciliation/agentReconciliation/run.ts

@@ -8,7 +8,6 @@ import {
 import { isAgentInVault, resolveConfiguredVaultAddress } from '../../../registry/vault.js'
 import type { EthagentConfig, EthagentIdentity } from '../../../../storage/config.js'
 import { readVaultAddressField } from '../../../identityCompat.js'
-import { reconcileWalletSetup, type RecordsFixPlan } from '../walletSetup.js'
 import { readCustodyMode } from '../../model/custody.js'
 import { continuityWorkingTreeStatus, type ContinuityWorkingTreeStatus } from '../../../continuity/storage.js'
 import type { AgentReconciliation } from './types.js'
@@ -18,7 +17,6 @@ export function emptyReconciliation(): AgentReconciliation {
     token: 'no-agent',
     custody: 'unknown',
     agentUri: 'unknown',
-    ensRecords: 'unset',
     vault: 'unset',
     workingTree: 'unknown',
     rpc: 'reachable',
@@ -52,7 +50,6 @@ export async function runReconciliation(
       tokenDetail: `no rpcUrl configured for chain ${identity.chainId}`,
       custody: 'unknown',
       agentUri: 'unknown',
-      ensRecords: 'unknown',
       vault: vaultAddress ? 'unknown' : 'unset',
       workingTree: 'unknown',
       rpc: 'failing',
@@ -67,14 +64,12 @@ export async function runReconciliation(
     tokenResult,
     custodyResult,
     agentUriResult,
-    ensReconcileResult,
     vaultResult,
     workingTreeResult,
   ] = await Promise.allSettled([
     probeToken({ registry, agentId, expectedOwner, operatorVaults }),
     probeCustody({ client, registry, agentId, expectedOwner, vaultAddress, identity }),
     probeAgentUri({ client, registry, agentId, identity }),
-    probeEnsRecords({ identity, registry, client }),
     probeVault({ client, vaultAddress }),
     probeWorkingTree(identity),
   ])
@@ -82,11 +77,10 @@ export async function runReconciliation(
   const token = unwrap(tokenResult, fallbackToken)
   const custody = unwrap(custodyResult, () => ({ kind: 'unknown' as const }))
   const agentUri = unwrap(agentUriResult, () => ({ kind: 'unknown' as const }))
-  const ensRecords = unwrap(ensReconcileResult, () => ({ kind: 'unknown' as const }))
   const vault = unwrap(vaultResult, () => ({ kind: vaultAddress ? 'unknown' as const : 'unset' as const }))
   const workingTree = unwrap(workingTreeResult, () => ({ kind: 'unknown' as const }))
 
-  const allFailed = [tokenResult, custodyResult, agentUriResult, ensReconcileResult, vaultResult]
+  const allFailed = [tokenResult, custodyResult, agentUriResult, vaultResult]
     .every(r => r.status === 'rejected')
   const rpc: 'reachable' | 'failing' = allFailed ? 'failing' : 'reachable'
 
@@ -99,8 +93,6 @@ export async function runReconciliation(
     ...(token.kind === 'unknown' && token.detail ? { tokenDetail: token.detail } : {}),
     custody: custody.kind,
     agentUri: agentUri.kind,
-    ensRecords: ensRecords.kind,
-    ...(ensRecords.kind === 'drift' || ensRecords.kind === 'aligned' ? { ensRecordsPlan: ensRecords.plan } : {}),
     vault: vault.kind,
     workingTree: workingTree.kind,
     rpc,
@@ -232,30 +224,6 @@ async function probeAgentUri(args: {
   }
 }
 
-type EnsRecordsProbe =
-  | { kind: 'aligned'; plan: RecordsFixPlan }
-  | { kind: 'drift'; plan: RecordsFixPlan }
-  | { kind: 'unset' }
-  | { kind: 'unknown' }
-
-async function probeEnsRecords(args: {
-  identity: EthagentIdentity
-  registry: Erc8004RegistryConfig
-  client: PublicClient
-}): Promise<EnsRecordsProbe> {
-  const baseState = (args.identity.state ?? {}) as Record<string, unknown>
-  const ensName = typeof baseState.ensName === 'string' ? baseState.ensName.trim() : ''
-  const custody = readCustodyMode(baseState)
-  if (!ensName || custody !== 'advanced') return { kind: 'unset' }
-  try {
-    const plan = await reconcileWalletSetup({ identity: args.identity, registry: args.registry })
-    if (plan.items.length === 0) return { kind: 'aligned', plan }
-    const actionable = plan.items.some(item => item.kind === 'missing-approval' || item.kind === 'stale-approval')
-    return actionable ? { kind: 'drift', plan } : { kind: 'aligned', plan }
-  } catch {
-    return { kind: 'unknown' }
-  }
-}
 
 type VaultProbe = { kind: 'confirmed' | 'missing' | 'unset' | 'unknown' }
 
@@ -295,7 +263,6 @@ function computeDriftCount(r: AgentReconciliation): number {
   if (r.token === 'unlinked') n++
   if (r.custody === 'mid-flow-uri-pending') n++
   if (r.agentUri === 'local-newer' || r.agentUri === 'chain-newer') n++
-  if (r.ensRecords === 'drift') n++
   if (r.vault === 'missing') n++
   if (r.workingTree === 'dirty') n++
   return n

package/src/identity/hub/reconciliation/agentReconciliation/types.ts

@@ -1,5 +1,3 @@
-import type { RecordsFixPlan } from '../walletSetup.js'
-
 export type AgentReconciliation = {
   token: 'linked' | 'unlinked' | 'unknown' | 'no-agent'
   tokenDetail?: string
@@ -7,8 +5,6 @@ export type AgentReconciliation = {
   onChainOwner?: string
   custody: 'simple' | 'advanced' | 'withdrawn' | 'mid-flow-uri-pending' | 'unknown'
   agentUri: 'in-sync' | 'chain-newer' | 'local-newer' | 'unknown'
-  ensRecords: 'aligned' | 'drift' | 'unset' | 'unknown'
-  ensRecordsPlan?: RecordsFixPlan
   vault: 'confirmed' | 'missing' | 'unset' | 'unknown'
   workingTree: 'clean' | 'dirty' | 'unknown'
   rpc: 'reachable' | 'failing'

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

@@ -8,14 +8,7 @@ export type {
 } from './useAgentReconciliation.js'
 export {
   computeApprovalDiff,
-  describeFixPlanItem,
-  encodeResolverApprovalChanges,
-  fixPlanRequiresOwnerWallet,
-  reconcileWalletSetup,
-  verifyResolverApprovalsLanded,
 } from './walletSetup.js'
 export type {
   ApprovalDiff,
-  RecordsFixPlan,
-  RecordsFixPlanItem,
 } from './walletSetup.js'

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

@@ -1,23 +1,4 @@
-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'
+import { getAddress, type Address } from 'viem'
 
 export type ApprovalDiff = {
   added: Address[]
@@ -44,177 +25,3 @@ export function computeApprovalDiff(
   }
   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/wallet/browserWallet/types.ts

@@ -27,9 +27,6 @@ export type WalletPurpose =
   | 'set-agent-ens-records'
   | 'update-operators'
   | 'operator-proof'
-  | 'authorize-operator-wallet-resolver'
-  | 'revoke-operator-wallet-resolver'
-  | 'reconcile-resolver-approvals'
   | 'sync-operator-vault'
   | 'refetch-snapshot'
   | 'prepare-transfer-sender'
@@ -41,8 +38,6 @@ export type WalletPurpose =
   | 'rotate-agent-uri-vault-owner'
   | 'rotate-agent-uri-vault-operator'
   | 'withdraw-vault'
-  | 'register-root-commit'
-  | 'register-root-tx'
   | 'delete-ens-subdomain'
 
 export type SignatureRequest = {

package/src/identity/wallet/page/copy.ts

@@ -123,7 +123,7 @@ export const PURPOSE_COPY: Record<string, PurposeCopyEntry> = {
     flowTitle: "Operator Wallet Profile Update",
     sign: { text: "Sign With Operator Wallet", hint: "Signs the encrypted snapshot for restore access." },
     prepare: { text: "Preparing Profile Update...", hint: "Keep this page open." },
-    transaction: { text: "Use Operator Wallet", hint: "Publishes the updated agent-card pointer to the ENS profile record on Ethereum Mainnet." },
+    transaction: { text: "Use Operator Wallet", hint: "Rotates the agent URI through the Vault. No ENS write." },
   },
   "update-profile-connected": {
     flowTitle: "Update Public Profile",
@@ -178,21 +178,6 @@ export const PURPOSE_COPY: Record<string, PurposeCopyEntry> = {
     sign: { text: "Sign With Operator Wallet", hint: "Creates restore access. No token approval." },
     prepare: { text: "Verifying Operator Wallet...", hint: "Return to the terminal." },
   },
-  "authorize-operator-wallet-resolver": {
-    flowTitle: "Owner Wallet Required",
-    prepare: { text: "Preparing Resolver Approval...", hint: "Keep this page open." },
-    transaction: { text: "Use Owner Wallet", hint: "Approves the operator wallet to write ENS records for this name. No token approval." },
-  },
-  "revoke-operator-wallet-resolver": {
-    flowTitle: "Owner Wallet Required",
-    prepare: { text: "Preparing Resolver Revocation...", hint: "Keep this page open." },
-    transaction: { text: "Use Owner Wallet", hint: "Revokes the operator wallet's ENS record write access for this name." },
-  },
-  "reconcile-resolver-approvals": {
-    flowTitle: "Owner Wallet Required",
-    prepare: { text: "Preparing Records Fix...", hint: "Keep this page open." },
-    transaction: { text: "Use Owner Wallet", hint: "Brings ENS resolver approvals in sync with the authorized operator wallet list." },
-  },
   "sync-operator-vault": {
     flowTitle: "Owner Wallet Required",
     prepare: { text: "Preparing Vault Operator Update...", hint: "Keep this page open." },
@@ -253,18 +238,6 @@ export const PURPOSE_COPY: Record<string, PurposeCopyEntry> = {
     transaction: { text: "Use Owner Wallet", hint: "Temporarily returns the agent token from the vault to your owner wallet. Vault stays configured so you can redeposit later." },
     errorContext: "While submitting the Vault withdraw",
   },
-  "register-root-commit": {
-    flowTitle: "Commit ENS Name",
-    prepare: { text: "Preparing ENS Commit...", hint: "Keep this page open." },
-    transaction: { text: "Use Connected Wallet", hint: "Submits an ENS commitment, the first of two transactions. The actual registration runs about 60 seconds later." },
-    errorContext: "While committing the ENS name registration",
-  },
-  "register-root-tx": {
-    flowTitle: "Register ENS Name",
-    prepare: { text: "Preparing ENS Registration...", hint: "Keep this page open." },
-    transaction: { text: "Use Connected Wallet", hint: "Pays the 1-year rent and registers the name. The connected wallet becomes the owner." },
-    errorContext: "While registering the ENS name",
-  },
   "delete-ens-subdomain": {
     flowTitle: "Delete ENS Subdomain",
     prepare: { text: "Preparing Subdomain Deletion...", hint: "Keep this page open." },
@@ -301,9 +274,6 @@ export const ENS_PURPOSES: ReadonlySet<string> = new Set([
   "set-agent-ens-records",
   "update-ens-records",
   "clear-ens-records",
-  "authorize-operator-wallet-resolver",
-  "revoke-operator-wallet-resolver",
-  "reconcile-resolver-approvals",
 ]);
 export function isEnsPurpose(purpose: string | undefined): boolean {
   return !!purpose && ENS_PURPOSES.has(purpose);

package/src/identity/wallet/walletPurposeCompat.ts

@@ -9,8 +9,6 @@ export const LEGACY_WALLET_PURPOSE_ALIASES: Record<string, string> = {
   [legacyWalletPurpose('connect', legacyOperatorRole)]: 'connect-operator-wallet',
   [legacyWalletPurpose('restore', legacyOwnerRole)]: 'restore-owner-wallet',
   [legacyWalletPurpose('restore', legacyOperatorRole)]: 'restore-operator-wallet',
-  [legacyWalletPurpose('authorize', legacyOperatorRole, 'wallet-resolver')]: 'authorize-operator-wallet-resolver',
-  [legacyWalletPurpose('revoke', legacyOperatorRole, 'wallet-resolver')]: 'revoke-operator-wallet-resolver',
 }
 
 export function normalizeWalletPurposeValue(value: unknown): string | undefined {