ethagent 3.0.1 → 3.1.0

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

@@ -77,6 +77,10 @@ import {
   syncVaultOperatorsAfterOwnerSave,
 } from '../shared/effects/sync.js'
 import { runOperatorWalletRebackup } from './vault.js'
+import {
+  rebackupCompletionMessage,
+  rebackupWalletPurpose,
+} from './completion.js'
 
 type BackupMetadata = NonNullable<EthagentIdentity['backup']>
 type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
@@ -418,65 +422,4 @@ export async function runRebackupStorageSubmit(
   callbacks.onStep({ kind: 'rebackup-signing', identity: step.identity, registry: step.registry, pinataJwt, profileUpdates: step.profileUpdates, returnTo: step.returnTo, walletPurpose: step.walletPurpose, vaultAddress: step.vaultAddress })
 }
 
-function rebackupWalletPurpose(
-  identity: EthagentIdentity,
-  profileUpdates: ProfileUpdates | undefined,
-): WalletPurpose {
-  const role = snapshotSaveWalletRole(identity, profileUpdates)
-  const snapshotPurpose = role === 'operator'
-    ? 'update-snapshot-operator' as const
-    : role === 'owner'
-      ? 'update-snapshot-owner' as const
-      : 'update-snapshot-connected' as const
-  const profilePurpose = role === 'operator'
-    ? 'update-profile-operator' as const
-    : role === 'owner'
-      ? 'update-profile-owner' as const
-      : 'update-profile-connected' as const
-  if (!profileUpdates) return snapshotPurpose
-  const baseState = (identity.state ?? {}) as Record<string, unknown>
-  const currentEns = typeof baseState.ensName === 'string' ? baseState.ensName.trim() : ''
-  const ensTouched = typeof profileUpdates.ensName === 'string'
-  const profileFieldsTouched = profileUpdates.name !== undefined
-    || profileUpdates.description !== undefined
-    || profileUpdates.imagePath !== undefined
-  const operatorFieldsTouched = profileUpdates.ownerAddress !== undefined
-    || profileUpdates.approvedOperatorWallets !== undefined
-    || profileUpdates.activeOperatorAddress !== undefined
-    || profileUpdates.restoreAccessEpoch !== undefined
-  if (operatorFieldsTouched && !ensTouched && !profileFieldsTouched) return 'update-operators'
-  if (ensTouched && !profileFieldsTouched) {
-    const next = (profileUpdates.ensName ?? '').trim()
-    if (!next && currentEns) return 'clear-ens'
-    return 'update-ens'
-  }
-  if (profileFieldsTouched) return profilePurpose
-  return snapshotPurpose
-}
-
-export function rebackupCompletionMessage(
-  profileUpdates: ProfileUpdates | undefined,
-  identity: EthagentIdentity,
-  ensOk?: boolean,
-): string {
-  if (!profileUpdates) return 'Backup Saved'
-  const baseState = (identity.state ?? {}) as Record<string, unknown>
-  const currentEns = typeof baseState.ensName === 'string' ? baseState.ensName.trim() : ''
-  const ensTouched = typeof profileUpdates.ensName === 'string'
-  const profileFieldsTouched = profileUpdates.name !== undefined
-    || profileUpdates.description !== undefined
-    || profileUpdates.imagePath !== undefined
-  const operatorFieldsTouched = profileUpdates.ownerAddress !== undefined
-    || profileUpdates.approvedOperatorWallets !== undefined
-    || profileUpdates.activeOperatorAddress !== undefined
-    || profileUpdates.restoreAccessEpoch !== undefined
-  if (operatorFieldsTouched && !ensTouched && !profileFieldsTouched) return 'Operator Wallets Updated'
-  if (ensTouched && !profileFieldsTouched) {
-    const next = (profileUpdates.ensName ?? '').trim()
-    if (!next && currentEns) return 'ENS Unlinked'
-    if (next) return ensOk === false ? 'ENS Issue' : 'ENS Linked'
-    return 'ENS Updated'
-  }
-  if (profileFieldsTouched) return 'Profile Updated'
-  return 'Backup Saved'
-}
+export { rebackupCompletionMessage } from './completion.js'

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

@@ -6,21 +6,15 @@ import {
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
-  prepareSyncedSkillsTree,
   prepareSyncedPublicSkillsJson,
-  readContinuityFiles,
   writePublicSkillsFile,
 } from '../../continuity/storage.js'
 import {
-  appendPublicSkillEntries,
   createAgentCard,
   defaultPublicSkillsProfile,
   serializeAgentCard,
 } from '../../continuity/publicSkills.js'
-import {
-  derivePublicSkillEntries,
-  syncPublicSkillsManifest,
-} from '../../continuity/skills/publicSkillsSync.js'
+import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
 import {
@@ -30,10 +24,7 @@ import {
   withEthagentPointers,
   type Erc8004RegistryConfig,
 } from '../../registry/erc8004.js'
-import {
-  VAULT_ABI,
-  encodeRotateAgentURI,
-} from '../../registry/vault.js'
+import { encodeRotateAgentURI } from '../../registry/vault.js'
 import { resolveValidatedPinataJwt, savePinataJwt } from '../../storage/pinataJwt.js'
 import {
   openBrowserWalletSession,
@@ -67,8 +58,11 @@ import {
   walletRestoreAccessContext,
 } from '../continuity/snapshot.js'
 import { rebackupCompletionMessage } from '../continuity/effects.js'
+import {
+  assertVaultSignerCanRotateAgentUri,
+  prepareOperatorProfileArtifacts,
+} from './operatorSave.js'
 
-type BackupMetadata = NonNullable<EthagentIdentity['backup']>
 type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
 
 type PublicProfilePreparedTransaction = {
@@ -369,164 +363,6 @@ async function runOperatorWalletVaultPublicProfileSave(args: {
   }
 }
 
-type OperatorProfileArtifacts = {
-  nextIdentity: EthagentIdentity
-  publicSkillsJson: string
-  agentUri: string
-  metadataCid: string
-}
-
-async function prepareOperatorProfileArtifacts(args: {
-  step: Extract<Step, { kind: 'public-profile-signing' }>
-  wallet: BrowserWalletSignature
-  snapshotOwner: Address
-  walletAccess: WalletAccessContext
-  challengePurpose: WalletChallengePurpose
-}): Promise<OperatorProfileArtifacts> {
-  const { step, wallet, snapshotOwner, walletAccess, challengePurpose } = args
-  const {
-    state,
-    nextName,
-    nextDescription,
-    nextEnsName,
-    uploadedImageUri,
-  } = await prepareProfileStateForSave({
-    identity: step.identity,
-    registry: step.registry,
-    profileUpdates: step.profileUpdates,
-    pinataJwt: step.pinataJwt,
-    ownerAddress: snapshotOwner,
-    walletAccount: getAddress(wallet.account),
-    includeLastBackedUpAt: true,
-  })
-  const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
-
-  const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
-  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(publicSkillsPin)
-  const publicSkillEntries = await derivePublicSkillEntries(nextIdentityForFiles)
-  const augmentedPublicProfile = appendPublicSkillEntries(
-    defaultPublicSkillsProfile(nextIdentityForFiles),
-    publicSkillEntries,
-  )
-  const agentCardPin = await addToIpfs(
-    DEFAULT_IPFS_API_URL,
-    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
-    fetch,
-    { pinataJwt: step.pinataJwt },
-  )
-  assertVerifiedPin(agentCardPin)
-
-  const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
-  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
-  const envelope = createContinuityEnvelopeForSave({
-    identity: nextIdentityForFiles,
-    registry: step.registry,
-    ownerAddress: snapshotOwner,
-    signerAddress: wallet.account,
-    walletSignature: wallet.signature,
-    state,
-    files: continuityFiles,
-    skills: skillsTree,
-    walletAccess,
-    challengePurpose,
-  })
-  const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(statePin)
-
-  const publicSkills: PublicSkillsMetadata = {
-    cid: publicSkillsPin.cid,
-    agentCardCid: agentCardPin.cid,
-    updatedAt: envelope.createdAt,
-    status: 'pinned',
-  }
-  const backup: BackupMetadata = {
-    cid: statePin.cid,
-    createdAt: envelope.createdAt,
-    envelopeVersion: envelope.envelopeVersion,
-    ipfsApiUrl: DEFAULT_IPFS_API_URL,
-    status: 'pinned',
-    ownerAddress: snapshotOwner,
-    chainId: step.registry.chainId,
-    rpcUrl: step.registry.rpcUrl,
-    identityRegistryAddress: step.registry.identityRegistryAddress,
-    agentId: step.identity.agentId!,
-  }
-
-  const registration = withEthagentPointers({
-    type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
-    name: nextName ?? deriveAgentName(step.identity),
-    ...(nextDescription ? { description: nextDescription } : {}),
-    ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
-  }, {
-    backup: { cid: statePin.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, agentId: step.identity.agentId },
-    ensName: nextEnsName,
-    operators: operatorsPointerFromState(state, nextEnsName),
-    ownerAddress: snapshotOwner,
-  })
-  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}`
-
-  const nextIdentity: EthagentIdentity = {
-    ...step.identity,
-    state,
-    backup: { ...backup, metadataCid, agentUri },
-    publicSkills,
-    agentUri,
-    metadataCid,
-  }
-
-  return {
-    nextIdentity,
-    publicSkillsJson,
-    agentUri,
-    metadataCid,
-  }
-}
-
-async function assertVaultSignerCanRotateAgentUri(args: {
-  registry: Erc8004RegistryConfig
-  vaultAddress: Address
-  agentId: bigint
-  signer: Address
-}): Promise<void> {
-  const client = createErc8004PublicClient(args.registry)
-  const registryAddress = getAddress(args.registry.identityRegistryAddress)
-  const vaultAddress = getAddress(args.vaultAddress)
-  const signer = getAddress(args.signer)
-  let vaultOwner: Address
-  try {
-    vaultOwner = getAddress(await client.readContract({
-      address: vaultAddress,
-      abi: VAULT_ABI,
-      functionName: 'agentOwner',
-      args: [registryAddress, args.agentId],
-    }) as Address)
-  } catch (err: unknown) {
-    throw new Error(`Could not verify Vault custody for agent #${args.agentId.toString()}: ${err instanceof Error ? err.message : String(err)}`)
-  }
-  if (vaultOwner === '0x0000000000000000000000000000000000000000') {
-    throw new Error(`Vault ${vaultAddress} does not currently hold agent token #${args.agentId.toString()}. Connect the owner wallet and run "Fix Records" or return the token to the vault before retrying.`)
-  }
-  if (vaultOwner.toLowerCase() === signer.toLowerCase()) return
-
-  const isOperator = await client.readContract({
-    address: vaultAddress,
-    abi: VAULT_ABI,
-    functionName: 'metadataOperators',
-    args: [registryAddress, args.agentId, signer],
-  }) as boolean
-  if (isOperator) return
-
-  throw new Error(
-    `Operator wallet ${signer} is not yet authorized on the Vault to rotate this agent's URI. Connect the owner wallet and run "Fix Records" or re-add this operator to grant the permission.`,
-  )
-}
-
 export async function runPublicProfileStorageSubmit(
   input: string,
   step: Extract<Step, { kind: 'public-profile-storage' }>,

package/src/identity/hub/profile/operatorSave.ts

@@ -0,0 +1,202 @@
+import { getAddress, type Address } from 'viem'
+import type { EthagentIdentity } from '../../../storage/config.js'
+import {
+  createWalletRestoreAccessChallenge,
+  serializeContinuitySnapshotEnvelope,
+  type WalletChallengePurpose,
+} from '../../continuity/envelope.js'
+import {
+  prepareSyncedSkillsTree,
+  readContinuityFiles,
+} from '../../continuity/storage.js'
+import {
+  appendPublicSkillEntries,
+  createAgentCard,
+  defaultPublicSkillsProfile,
+  serializeAgentCard,
+} from '../../continuity/publicSkills.js'
+import {
+  derivePublicSkillEntries,
+  syncPublicSkillsManifest,
+} from '../../continuity/skills/publicSkillsSync.js'
+import { addToIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
+import {
+  createErc8004PublicClient,
+  withEthagentPointers,
+  type Erc8004RegistryConfig,
+} from '../../registry/erc8004.js'
+import { VAULT_ABI } from '../../registry/vault.js'
+import type { BrowserWalletSignature } from '../../wallet/browserWallet.js'
+import type { Step } from '../identityHubReducer.js'
+import {
+  assertVerifiedPin,
+  deriveAgentName,
+  prepareProfileStateForSave,
+} from '../shared/effects/profilePrep.js'
+import {
+  createContinuityEnvelopeForSave,
+  operatorsPointerFromState,
+  walletRestoreAccessContext,
+} from '../continuity/snapshot.js'
+
+type BackupMetadata = NonNullable<EthagentIdentity['backup']>
+type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type WalletAccessContext = NonNullable<ReturnType<typeof walletRestoreAccessContext>>
+
+export type OperatorProfileArtifacts = {
+  nextIdentity: EthagentIdentity
+  publicSkillsJson: string
+  agentUri: string
+  metadataCid: string
+}
+
+export async function prepareOperatorProfileArtifacts(args: {
+  step: Extract<Step, { kind: 'public-profile-signing' }>
+  wallet: BrowserWalletSignature
+  snapshotOwner: Address
+  walletAccess: WalletAccessContext
+  challengePurpose: WalletChallengePurpose
+}): Promise<OperatorProfileArtifacts> {
+  const { step, wallet, snapshotOwner, walletAccess, challengePurpose } = args
+  const {
+    state,
+    nextName,
+    nextDescription,
+    nextEnsName,
+    uploadedImageUri,
+  } = await prepareProfileStateForSave({
+    identity: step.identity,
+    registry: step.registry,
+    profileUpdates: step.profileUpdates,
+    pinataJwt: step.pinataJwt,
+    ownerAddress: snapshotOwner,
+    walletAccount: getAddress(wallet.account),
+    includeLastBackedUpAt: true,
+  })
+  const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
+
+  const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
+  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
+  assertVerifiedPin(publicSkillsPin)
+  const publicSkillEntries = await derivePublicSkillEntries(nextIdentityForFiles)
+  const augmentedPublicProfile = appendPublicSkillEntries(
+    defaultPublicSkillsProfile(nextIdentityForFiles),
+    publicSkillEntries,
+  )
+  const agentCardPin = await addToIpfs(
+    DEFAULT_IPFS_API_URL,
+    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
+    fetch,
+    { pinataJwt: step.pinataJwt },
+  )
+  assertVerifiedPin(agentCardPin)
+
+  const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
+  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
+  const envelope = createContinuityEnvelopeForSave({
+    identity: nextIdentityForFiles,
+    registry: step.registry,
+    ownerAddress: snapshotOwner,
+    signerAddress: wallet.account,
+    walletSignature: wallet.signature,
+    state,
+    files: continuityFiles,
+    skills: skillsTree,
+    walletAccess,
+    challengePurpose,
+  })
+  const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
+  assertVerifiedPin(statePin)
+
+  const publicSkills: PublicSkillsMetadata = {
+    cid: publicSkillsPin.cid,
+    agentCardCid: agentCardPin.cid,
+    updatedAt: envelope.createdAt,
+    status: 'pinned',
+  }
+  const backup: BackupMetadata = {
+    cid: statePin.cid,
+    createdAt: envelope.createdAt,
+    envelopeVersion: envelope.envelopeVersion,
+    ipfsApiUrl: DEFAULT_IPFS_API_URL,
+    status: 'pinned',
+    ownerAddress: snapshotOwner,
+    chainId: step.registry.chainId,
+    rpcUrl: step.registry.rpcUrl,
+    identityRegistryAddress: step.registry.identityRegistryAddress,
+    agentId: step.identity.agentId!,
+  }
+
+  const registration = withEthagentPointers({
+    type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
+    name: nextName ?? deriveAgentName(step.identity),
+    ...(nextDescription ? { description: nextDescription } : {}),
+    ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
+  }, {
+    backup: { cid: statePin.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, agentId: step.identity.agentId },
+    ensName: nextEnsName,
+    operators: operatorsPointerFromState(state, nextEnsName),
+    ownerAddress: snapshotOwner,
+  })
+  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}`
+
+  const nextIdentity: EthagentIdentity = {
+    ...step.identity,
+    state,
+    backup: { ...backup, metadataCid, agentUri },
+    publicSkills,
+    agentUri,
+    metadataCid,
+  }
+
+  return {
+    nextIdentity,
+    publicSkillsJson,
+    agentUri,
+    metadataCid,
+  }
+}
+
+export async function assertVaultSignerCanRotateAgentUri(args: {
+  registry: Erc8004RegistryConfig
+  vaultAddress: Address
+  agentId: bigint
+  signer: Address
+}): Promise<void> {
+  const client = createErc8004PublicClient(args.registry)
+  const registryAddress = getAddress(args.registry.identityRegistryAddress)
+  const vaultAddress = getAddress(args.vaultAddress)
+  const signer = getAddress(args.signer)
+  let vaultOwner: Address
+  try {
+    vaultOwner = getAddress(await client.readContract({
+      address: vaultAddress,
+      abi: VAULT_ABI,
+      functionName: 'agentOwner',
+      args: [registryAddress, args.agentId],
+    }) as Address)
+  } catch (err: unknown) {
+    throw new Error(`Could not verify Vault custody for agent #${args.agentId.toString()}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+  if (vaultOwner === '0x0000000000000000000000000000000000000000') {
+    throw new Error(`Vault ${vaultAddress} does not currently hold agent token #${args.agentId.toString()}. Connect the owner wallet and run "Fix Records" or return the token to the vault before retrying.`)
+  }
+  if (vaultOwner.toLowerCase() === signer.toLowerCase()) return
+
+  const isOperator = await client.readContract({
+    address: vaultAddress,
+    abi: VAULT_ABI,
+    functionName: 'metadataOperators',
+    args: [registryAddress, args.agentId, signer],
+  }) as boolean
+  if (isOperator) return
+
+  throw new Error(
+    `Operator wallet ${signer} is not yet authorized on the Vault to rotate this agent's URI. Connect the owner wallet and run "Fix Records" or re-add this operator to grant the permission.`,
+  )
+}

package/src/identity/registry/erc8004/metadata.ts

@@ -181,16 +181,15 @@ function serializeOperatorsPointer(pointer: EthagentOperatorsPointer): Record<st
 export function withEthagentBackupPointer(
   registration: Record<string, unknown> | null,
   backup: EthagentBackupPointer,
-  publicDiscovery?: EthagentPublicDiscoveryPointer,
-  registrationPointer?: EthagentRegistrationPointer,
-  ownerAddress?: Address,
+  publicDiscovery: EthagentPublicDiscoveryPointer | undefined,
+  registrationPointer: EthagentRegistrationPointer | undefined,
+  ownerAddress: Address,
 ): Record<string, unknown> {
-  const inferredOwnerAddress = ownerAddress ?? backup.agentAddress
   return withEthagentPointers(registration, {
     backup,
     publicDiscovery,
     registration: registrationPointer,
-    ...(inferredOwnerAddress ? { ownerAddress: inferredOwnerAddress } : {}),
+    ownerAddress,
   })
 }
 
@@ -202,29 +201,26 @@ export function withEthagentPointers(
     registration?: EthagentRegistrationPointer
     ensName?: string
     operators?: EthagentOperatorsPointer
-    ownerAddress?: Address
+    ownerAddress: Address
   },
 ): Record<string, unknown> {
   const next: Record<string, unknown> = registration ? { ...registration } : {}
   const prior = objectField(next, 'x-ethagent') ?? {}
   const { backup, publicDiscovery, registration: registrationPointer, operators } = pointers
   const updatedAt = publicDiscovery?.updatedAt ?? backup?.createdAt
-  const ownerAddress = pointers.ownerAddress
-    ? getAddress(pointers.ownerAddress)
-    : backup?.agentAddress
-      ? getAddress(backup.agentAddress)
-      : undefined
+  if (!pointers.ownerAddress) {
+    throw new Error('withEthagentPointers requires ownerAddress')
+  }
+  const ownerAddress = getAddress(pointers.ownerAddress)
   const priorX402 = objectField(prior, 'x402') ?? {}
   const ext: Record<string, unknown> = {
     ...prior,
     version: 1,
-    ...(ownerAddress ? {
-      agentAddress: ownerAddress,
-      x402: {
-        ...priorX402,
-        walletAddress: ownerAddress,
-      },
-    } : {}),
+    agentAddress: ownerAddress,
+    x402: {
+      ...priorX402,
+      walletAddress: ownerAddress,
+    },
     ...(backup ? {
       backup: {
         cid: backup.cid,
@@ -252,8 +248,11 @@ export function withEthagentPointers(
   delete ext.transfer
   delete ext.handoff
   next['x-ethagent'] = ext
-  if (publicDiscovery) {
-    next.services = withPublicDiscoveryServices(next.services, publicDiscovery, pointers.ensName)
+  const agentWalletService = registrationPointer
+    ? { name: 'agentWallet' as const, endpoint: `eip155:${registrationPointer.chainId}:${ownerAddress}` }
+    : undefined
+  if (publicDiscovery || agentWalletService) {
+    next.services = withEthagentServices(next.services, publicDiscovery, pointers.ensName, agentWalletService)
   }
   if (registrationPointer && registrationPointer.agentId !== undefined) {
     next.registrations = withRegistrationsArray(next.registrations, registrationPointer)
@@ -272,10 +271,18 @@ function serializeTransferSnapshotMetadata(metadata: TransferSnapshotMetadata):
   }
 }
 
-function withPublicDiscoveryServices(input: unknown, publicDiscovery: EthagentPublicDiscoveryPointer, ensName?: string): unknown[] {
+function withEthagentServices(
+  input: unknown,
+  publicDiscovery: EthagentPublicDiscoveryPointer | undefined,
+  ensName: string | undefined,
+  agentWallet: { name: 'agentWallet'; endpoint: string } | undefined,
+): unknown[] {
   const prior = Array.isArray(input) ? input.filter(item => item && typeof item === 'object') : []
   const services = prior.filter(item => !isEthagentManagedService(item)) as unknown[]
-  if (publicDiscovery.agentCardCid) {
+  if (agentWallet) {
+    pushUniqueService(services, agentWallet)
+  }
+  if (publicDiscovery?.agentCardCid) {
     const endpoint = `ipfs://${publicDiscovery.agentCardCid}`
     pushUniqueService(services, {
       type: 'a2a',
@@ -284,7 +291,7 @@ function withPublicDiscoveryServices(input: unknown, publicDiscovery: EthagentPu
       url: endpoint,
     })
   }
-  if (publicDiscovery.skillsCid) {
+  if (publicDiscovery?.skillsCid) {
     const endpoint = `ipfs://${publicDiscovery.skillsCid}`
     pushUniqueService(services, {
       type: 'A2A-skills',
@@ -313,6 +320,7 @@ function isEthagentManagedService(item: unknown): boolean {
   const obj = item as Record<string, unknown>
   const type = obj.type
   const name = obj.name
+  if (name === 'agentWallet') return true
   if (name === 'ENS') return true
   if (type === 'a2a' && (name === undefined || name === 'agent-card')) return true
   return (type === 'A2A-skills' || type === 'ipfs') && name === 'public-skills'

package/src/identity/wallet/browserWallet/html.ts

@@ -1,26 +1,7 @@
-import { readFileSync, statSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { transformSync } from 'esbuild'
 import { normalizeWalletPayloadPurpose } from '../walletPurposeCompat.js'
+import { loadWalletPageSource } from './walletPageSource.js'
 
-const WALLET_PAGE_FILE = join(dirname(fileURLToPath(import.meta.url)), '..', 'page.tsx')
-const WALLET_PAGE_MODULE_FILES = [
-  join('page', 'types.ts'),
-  join('page', 'html.ts'),
-  join('page', 'constants.ts'),
-  join('page', 'styles', 'base.ts'),
-  join('page', 'styles', 'components.ts'),
-  join('page', 'styles', 'responsive.ts'),
-  join('page', 'styles', 'index.ts'),
-  join('page', 'markup.ts'),
-  join('page', 'grainient.ts'),
-  join('page', 'state.ts'),
-  join('page', 'copy.ts'),
-  join('page', 'walletProvider.ts'),
-  join('page', 'view.ts'),
-  join('page', 'controller.ts'),
-] as const
 const WALLET_HTML = loadWalletHtml()
 
 export function walletPage(title: string, sessionToken: string, payload: Record<string, unknown>): string {
@@ -43,43 +24,6 @@ function loadWalletHtml(): string {
   return wrapInWalletShell(compiled)
 }
 
-function loadWalletPageSource(): string {
-  const pageFile = locateWalletPageFile()
-  const pageDir = dirname(pageFile)
-  const files = [
-    ...WALLET_PAGE_MODULE_FILES.map(file => join(pageDir, file)),
-    pageFile,
-  ]
-  return stripWalletModuleSyntax(files.map(file => readFileSync(file, 'utf8')).join('\n'))
-}
-
-function stripWalletModuleSyntax(source: string): string {
-  const out: string[] = []
-  let skippingImport = false
-  for (const line of source.split(/\r?\n/)) {
-    const trimmed = line.trim()
-    if (skippingImport) {
-      if (/\bfrom\s+['"][^'"]+['"]/.test(trimmed) || trimmed.endsWith(';')) skippingImport = false
-      continue
-    }
-    if (trimmed.startsWith('import ')) {
-      if (!/\bfrom\s+['"][^'"]+['"]/.test(trimmed) && !trimmed.endsWith(';')) skippingImport = true
-      continue
-    }
-    out.push(line.replace(/^export\s+(?=(async\s+function|const|let|function|interface|type|class)\b)/, ''))
-  }
-  return out.join('\n')
-}
-
-function locateWalletPageFile(): string {
-  try {
-    statSync(WALLET_PAGE_FILE)
-    return WALLET_PAGE_FILE
-  } catch {
-    return join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..', '..', 'src', 'identity', 'wallet', 'page.tsx')
-  }
-}
-
 function wrapInWalletShell(compiledJs: string): string {
   const safeJs = compiledJs.replaceAll('</', '<\\/')
   return `<!doctype html>