ethagent 3.1.2 → 3.3.0

package/src/identity/continuity/storage/scaffold.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import { atomicWriteText } from '../../../storage/atomicWrite.js'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import type { ContinuityFiles, ContinuitySkillsTree } from '../envelope.js'
@@ -6,10 +8,10 @@ import {
   materializeSkillsTree,
 } from '../skills/loadSkills.js'
 import {
-  renderPublicSkillsJsonForIdentity,
-  syncPublicSkillsManifest,
+  renderAgentCardJsonForIdentity,
+  syncAgentCardManifest,
 } from '../skills/publicSkillsSync.js'
-import { defaultContinuityFiles, defaultPublicSkillsJson } from './defaults.js'
+import { defaultContinuityFiles, defaultAgentCardJson } from './defaults.js'
 import {
   ensureContinuityFiles,
   ensureContinuityVault,
@@ -24,14 +26,14 @@ import type { ContinuityVaultRef, IdentityMarkdownScaffold } from './types.js'
 
 export async function ensureIdentityMarkdownScaffold(
   identity: EthagentIdentity,
-  options: { publicSkillsFallback?: string | (() => Promise<string>) } = {},
+  options: { agentCardFallback?: string | (() => Promise<string>) } = {},
 ): Promise<IdentityMarkdownScaffold> {
   const privateFiles = await ensureContinuityFiles(identity)
-  const publicSkills = await ensurePublicSkillsFile(identity, { fallback: options.publicSkillsFallback })
-  const syncedPublic = await syncPublicSkillsManifest(identity).catch(() => publicSkills)
+  const agentCard = await ensureAgentCardFile(identity, { fallback: options.agentCardFallback })
+  const syncedCard = await syncAgentCardManifest(identity).catch(() => agentCard)
   return {
     ...privateFiles,
-    'skills.json': syncedPublic,
+    'agent-card.json': syncedCard,
   }
 }
 
@@ -43,7 +45,7 @@ export async function writeIdentityMarkdownScaffold(
     'SOUL.md': files['SOUL.md'],
     'MEMORY.md': files['MEMORY.md'],
   })
-  await writePublicSkillsFile(identity, files['skills.json'])
+  await writeAgentCardFile(identity, files['agent-card.json'])
   return ref
 }
 
@@ -57,7 +59,7 @@ export async function prepareSyncedIdentityMarkdownScaffold(identity: EthagentId
   await ensureIdentityMarkdownScaffold(identity)
   const privateFiles = await readContinuityFiles(identity)
   const privateDefaults = defaultContinuityFiles(identity)
-  const publicDefault = await renderPublicSkillsJsonForIdentity(identity)
+  const agentCardDefault = await renderAgentCardJsonForIdentity(identity)
   return {
     'SOUL.md': syncGeneratedMarkdown(privateFiles['SOUL.md'], privateDefaults['SOUL.md'], [
       { marker: 'identity' },
@@ -65,13 +67,13 @@ export async function prepareSyncedIdentityMarkdownScaffold(identity: EthagentId
     'MEMORY.md': syncGeneratedMarkdown(privateFiles['MEMORY.md'], privateDefaults['MEMORY.md'], [
       { marker: 'identity' },
     ]),
-    'skills.json': publicDefault,
+    'agent-card.json': agentCardDefault,
   }
 }
 
-export async function prepareSyncedPublicSkillsJson(identity: EthagentIdentity): Promise<string> {
-  await ensurePublicSkillsFile(identity)
-  return renderPublicSkillsJsonForIdentity(identity)
+export async function prepareSyncedAgentCardJson(identity: EthagentIdentity): Promise<string> {
+  await ensureAgentCardFile(identity)
+  return renderAgentCardJsonForIdentity(identity)
 }
 
 export async function prepareSyncedSkillsTree(identity: EthagentIdentity): Promise<ContinuitySkillsTree> {
@@ -87,30 +89,40 @@ export async function restoreSkillsTree(
 }
 
 
-export async function ensurePublicSkillsFile(
+export async function ensureAgentCardFile(
   identity: EthagentIdentity,
   options: { fallback?: string | (() => Promise<string>) } = {},
 ): Promise<string> {
   const ref = await ensureContinuityVault(identity)
-  if (await exists(ref.publicSkillsPath)) return readPublicSkillsFile(identity)
+  if (await exists(ref.agentCardPath)) return readAgentCardFile(identity)
 
-  const fallback = await resolvePublicSkillsFallback(identity, options.fallback)
-  await atomicWriteText(ref.publicSkillsPath, ensureTrailingNewline(fallback), { mode: 0o644 })
-  return readPublicSkillsFile(identity)
+  const legacyPath = path.join(ref.dir, 'skills.json')
+  if (await exists(legacyPath)) {
+    const legacyContent = await readOrDefault(legacyPath, '')
+    if (legacyContent) {
+      await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(legacyContent), { mode: 0o644 })
+    }
+    await fs.rm(legacyPath, { force: true })
+    if (await exists(ref.agentCardPath)) return readAgentCardFile(identity)
+  }
+
+  const fallback = await resolveAgentCardFallback(identity, options.fallback)
+  await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(fallback), { mode: 0o644 })
+  return readAgentCardFile(identity)
 }
 
-export async function readPublicSkillsFile(identity: EthagentIdentity): Promise<string> {
+export async function readAgentCardFile(identity: EthagentIdentity): Promise<string> {
   const ref = await ensureContinuityVault(identity)
-  return readOrDefault(ref.publicSkillsPath, defaultPublicSkillsJson(identity))
+  return readOrDefault(ref.agentCardPath, defaultAgentCardJson(identity))
 }
 
-export async function writePublicSkillsFile(identity: EthagentIdentity, content: string): Promise<ContinuityVaultRef> {
+export async function writeAgentCardFile(identity: EthagentIdentity, content: string): Promise<ContinuityVaultRef> {
   const ref = await ensureContinuityVault(identity)
-  await atomicWriteText(ref.publicSkillsPath, ensureTrailingNewline(content), { mode: 0o644 })
+  await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(content), { mode: 0o644 })
   return ref
 }
 
-async function resolvePublicSkillsFallback(
+async function resolveAgentCardFallback(
   identity: EthagentIdentity,
   fallback: string | (() => Promise<string>) | undefined,
 ): Promise<string> {
@@ -119,8 +131,8 @@ async function resolvePublicSkillsFallback(
     try {
       return await fallback()
     } catch {
-      return defaultPublicSkillsJson(identity)
+      return defaultAgentCardJson(identity)
     }
   }
-  return defaultPublicSkillsJson(identity)
+  return defaultAgentCardJson(identity)
 }

package/src/identity/continuity/storage/status.ts

@@ -2,10 +2,10 @@ import { createHash } from 'node:crypto'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import type { ContinuityFiles, ContinuitySkillsTree } from '../envelope.js'
 import { loadSkillsTree } from '../skills/loadSkills.js'
-import { syncPublicSkillsManifest } from '../skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../skills/publicSkillsSync.js'
 import { continuityVaultRef } from './paths.js'
 import { exists, readContinuityFiles, statIfExists } from './files.js'
-import { readPublicSkillsFile } from './scaffold.js'
+import { readAgentCardFile } from './scaffold.js'
 import type { ContinuityPublishState, ContinuitySnapshotContentHashes, ContinuityVaultRef, ContinuityWorkingTreeStatus } from './types.js'
 
 export async function continuityVaultStatus(identity: EthagentIdentity): Promise<{ ready: boolean; files: ContinuityVaultRef }> {
@@ -22,7 +22,7 @@ export async function continuityWorkingTreeStatus(
   const stats = await Promise.all([
     statIfExists(ref.soulPath),
     statIfExists(ref.memoryPath),
-    statIfExists(ref.publicSkillsPath),
+    statIfExists(ref.agentCardPath),
   ])
   const newestMs = Math.max(0, ...stats.flatMap(stat => stat ? [stat.mtimeMs] : []))
   const ready = Boolean(stats[0] && stats[1])
@@ -54,30 +54,30 @@ export async function localContinuitySnapshotContentHashes(
   identity: EthagentIdentity,
 ): Promise<ContinuitySnapshotContentHashes> {
   const privateFiles = await readContinuityFiles(identity)
-  await syncPublicSkillsManifest(identity).catch(() => undefined)
-  const publicSkills = await readPublicSkillsFile(identity)
+  await syncAgentCardManifest(identity).catch(() => undefined)
+  const agentCard = await readAgentCardFile(identity)
   const skills = await loadSkillsTree(identity).catch(() => ({} as ContinuitySkillsTree))
-  return continuitySnapshotContentHashes(privateFiles, publicSkills, skills)
+  return continuitySnapshotContentHashes(privateFiles, agentCard, skills)
 }
 
 export function continuitySnapshotContentHashesFromSources(args: {
   privateFiles: ContinuityFiles
-  publicSkills: string
+  agentCard: string
   skills: ContinuitySkillsTree
 }): ContinuitySnapshotContentHashes {
-  return continuitySnapshotContentHashes(args.privateFiles, args.publicSkills, args.skills)
+  return continuitySnapshotContentHashes(args.privateFiles, args.agentCard, args.skills)
 }
 
 function continuitySnapshotContentHashes(
   privateFiles: ContinuityFiles,
-  publicSkills: string,
+  agentCard: string,
   skills: ContinuitySkillsTree,
 ): ContinuitySnapshotContentHashes {
   const skillsHash = hashSkillsTree(skills)
   return {
     'SOUL.md': hashContinuitySnapshotContent(privateFiles['SOUL.md']),
     'MEMORY.md': hashContinuitySnapshotContent(privateFiles['MEMORY.md']),
-    'skills.json': hashContinuitySnapshotContent(publicSkills),
+    'agent-card.json': hashContinuitySnapshotContent(agentCard),
     ...(skillsHash ? { 'private-skills': skillsHash } : {}),
   }
 }
@@ -101,7 +101,7 @@ function equalContinuitySnapshotHashes(
 ): boolean {
   if (a['SOUL.md'] !== b['SOUL.md']) return false
   if (a['MEMORY.md'] !== b['MEMORY.md']) return false
-  if (a['skills.json'] !== b['skills.json']) return false
+  if (a['agent-card.json'] !== b['agent-card.json']) return false
   return a['private-skills'] === b['private-skills']
 }
 

package/src/identity/continuity/storage/types.ts

@@ -7,16 +7,16 @@ export type ContinuityVaultRef = {
   dir: string
   soulPath: string
   memoryPath: string
-  publicSkillsPath: string
+  agentCardPath: string
   skillsDir: string
 }
 
 export type IdentityMarkdownScaffold = ContinuityFiles & {
-  'skills.json': string
+  'agent-card.json': string
 }
 
-export type ContinuitySnapshotFile = PrivateContinuityFile | 'skills.json' | 'private-skills'
-export type ContinuitySnapshotContentHashes = Partial<Record<ContinuitySnapshotFile, string>> & Record<PrivateContinuityFile | 'skills.json', string>
+export type ContinuitySnapshotFile = PrivateContinuityFile | 'agent-card.json' | 'private-skills'
+export type ContinuitySnapshotContentHashes = Partial<Record<ContinuitySnapshotFile, string>> & Record<PrivateContinuityFile | 'agent-card.json', string>
 export type ContinuityPublishState = 'not-restored' | 'not-published' | 'verify-needed' | 'local-changes' | 'published'
 export type ContinuityWorkingTreeStatus = {
   ready: boolean

package/src/identity/continuity/storage.ts

@@ -17,15 +17,15 @@ export {
 export { continuityAgentSnapshot, defaultContinuityFiles } from './storage/defaults.js'
 export {
   ensureIdentityMarkdownScaffold,
-  ensurePublicSkillsFile,
+  ensureAgentCardFile,
   prepareSyncedIdentityMarkdownScaffold,
   prepareSyncedSkillsTree,
-  prepareSyncedPublicSkillsJson,
-  readPublicSkillsFile,
+  prepareSyncedAgentCardJson,
+  readAgentCardFile,
   restoreSkillsTree,
   syncIdentityMarkdownScaffold,
   writeIdentityMarkdownScaffold,
-  writePublicSkillsFile,
+  writeAgentCardFile,
 } from './storage/scaffold.js'
 export {
   continuityVaultStatus,

package/src/identity/ens/agentRecords.ts

@@ -1,51 +1,79 @@
-export const AGENT_RECORD_KEYS = {
-  token: 'org.ethagent.token',
-} as const
+import type { Address } from 'viem'
+import { encodeInteroperableAddress } from './erc7930.js'
 
-type AgentRecordKey = typeof AGENT_RECORD_KEYS[keyof typeof AGENT_RECORD_KEYS]
+export const AGENT_TOKEN_RECORD_KEY = 'org.ethagent.token'
 
-export const AGENT_RECORD_KEY_LIST: readonly AgentRecordKey[] = [
-  AGENT_RECORD_KEYS.token,
-] as const
-
-export const AGENT_RECORD_READ_KEY_LIST: readonly string[] = AGENT_RECORD_KEY_LIST
-
-export type AgentEnsRecords = {
-  token?: string
-}
-
-export type AgentEnsRecordState = AgentEnsRecords
+export type AgentEnsRecords = Record<string, string>
+export type AgentEnsRecordState = Record<string, string>
 
 export type AgentRecordDiff = {
-  key: AgentRecordKey
-  field: keyof AgentEnsRecordState
+  key: string
   current: string
   next: string
   changed: boolean
 }
 
-const FIELD_FOR_KEY: Record<AgentRecordKey, keyof AgentEnsRecords> = {
-  [AGENT_RECORD_KEYS.token]: 'token',
+export type Ensip25KeyArgs = {
+  chainId: number
+  identityRegistryAddress: Address | string
+  agentId: string | bigint
+}
+
+export function buildEnsip25Key(args: Ensip25KeyArgs): string {
+  const agentIdStr = typeof args.agentId === 'bigint' ? args.agentId.toString() : args.agentId.trim()
+  if (!agentIdStr) throw new Error('agentId is required to build the ENSIP-25 record key')
+  if (agentIdStr.includes('[') || agentIdStr.includes(']')) {
+    throw new Error('agentId must not contain square brackets per ENSIP-25')
+  }
+  const registry = encodeInteroperableAddress({
+    chainId: args.chainId,
+    address: args.identityRegistryAddress as Address,
+  })
+  return `agent-registration[${registry}][${agentIdStr}]`
 }
 
-const LABEL_FOR_FIELD: Record<keyof AgentEnsRecordState, string> = {
-  token: 'Agent token',
+export function buildAgentTokenReferenceValue(args: Ensip25KeyArgs): string {
+  const agentIdStr = typeof args.agentId === 'bigint' ? args.agentId.toString() : args.agentId.trim()
+  return `eip155:${args.chainId}:${(args.identityRegistryAddress as string).toLowerCase()}:${agentIdStr}`
 }
 
-export function recordsFromTextMap(text: Record<string, string>): AgentEnsRecordState {
+export function buildAgentEnsRecords(args: {
+  chainId: number
+  identityRegistryAddress: Address | string
+  agentId: string | bigint | undefined
+}): AgentEnsRecords {
+  if (args.agentId === undefined || args.agentId === '') return {}
+  const ensip25Key = buildEnsip25Key({
+    chainId: args.chainId,
+    identityRegistryAddress: args.identityRegistryAddress,
+    agentId: args.agentId,
+  })
+  const tokenValue = buildAgentTokenReferenceValue({
+    chainId: args.chainId,
+    identityRegistryAddress: args.identityRegistryAddress,
+    agentId: args.agentId,
+  })
   return {
-    token: text[AGENT_RECORD_KEYS.token] ?? '',
+    [ensip25Key]: '1',
+    [AGENT_TOKEN_RECORD_KEY]: tokenValue,
   }
 }
 
+export function recordsFromTextMap(text: Record<string, string>): AgentEnsRecordState {
+  const out: AgentEnsRecordState = {}
+  for (const [key, value] of Object.entries(text)) {
+    if (value) out[key] = value
+  }
+  return out
+}
+
 export function diffRecords(current: AgentEnsRecordState, next: AgentEnsRecords): AgentRecordDiff[] {
-  return AGENT_RECORD_KEY_LIST.map(key => {
-    const field = FIELD_FOR_KEY[key]
-    const currentValue = (current[field] ?? '').trim()
-    const nextValue = (next[field] ?? '').trim()
+  const keys = new Set<string>([...Object.keys(current), ...Object.keys(next)])
+  return Array.from(keys).map(key => {
+    const currentValue = (current[key] ?? '').trim()
+    const nextValue = (next[key] ?? '').trim()
     return {
       key,
-      field,
       current: currentValue,
       next: nextValue,
       changed: currentValue !== nextValue,
@@ -61,22 +89,10 @@ export function changedRecords(current: AgentEnsRecordState, next: AgentEnsRecor
   return out
 }
 
-export function recordLabel(field: keyof AgentEnsRecordState): string {
-  return LABEL_FOR_FIELD[field]
-}
-
-export function formatRecordValue(_field: keyof AgentEnsRecordState, value: string): string {
-  return value
-}
-
-export function buildAgentEnsRecords(args: {
-  chainId: number
-  identityRegistryAddress: string
-  agentId: string | undefined
-}): AgentEnsRecords {
-  const records: AgentEnsRecords = {}
-  if (args.agentId) {
-    records.token = `eip155:${args.chainId}:${args.identityRegistryAddress.toLowerCase()}:${args.agentId}`
+export function clearedRecords(current: AgentEnsRecordState): AgentEnsRecords {
+  const out: AgentEnsRecords = {}
+  for (const key of Object.keys(current)) {
+    out[key] = ''
   }
-  return records
+  return out
 }

package/src/identity/ens/ensAutomation/read.ts

@@ -9,7 +9,6 @@ import {
 } from 'viem'
 import { mainnet } from 'viem/chains'
 import {
-  AGENT_RECORD_READ_KEY_LIST,
   recordsFromTextMap,
   type AgentEnsRecordState,
 } from '../agentRecords.js'
@@ -81,9 +80,14 @@ export async function readAddressRecord(client: EnsAutomationReadClient, resolve
   }
 }
 
-export async function readTextRecords(client: EnsAutomationReadClient, resolverAddress: Address, node: Hex): Promise<AgentEnsRecordState> {
+export async function readTextRecords(
+  client: EnsAutomationReadClient,
+  resolverAddress: Address,
+  node: Hex,
+  keys: readonly string[],
+): Promise<AgentEnsRecordState> {
   const text: Record<string, string> = {}
-  for (const key of AGENT_RECORD_READ_KEY_LIST) {
+  for (const key of keys) {
     try {
       const value = await client.readContract({
         address: resolverAddress,
@@ -105,10 +109,3 @@ export function isZero(address: Address): boolean {
 export function sameAddress(a: Address, b: Address): boolean {
   return a.toLowerCase() === b.toLowerCase()
 }
-
-export function normalizeAgentRecords(records: AgentEnsRecordState): AgentEnsRecordState {
-  return {
-    ...records,
-    ...(records.token ? { token: records.token.toLowerCase() } : {}),
-  }
-}

package/src/identity/ens/ensAutomation/setup.ts

@@ -1,6 +1,8 @@
 import { getAddress, namehash, type Address } from 'viem'
 import {
+  AGENT_TOKEN_RECORD_KEY,
   buildAgentEnsRecords,
+  buildEnsip25Key,
   diffRecords,
 } from '../agentRecords.js'
 import { normalizeEthDomain, splitSubdomainName } from '../ensLookup.js'
@@ -12,7 +14,6 @@ import {
 import {
   createEnsAutomationClient,
   isZero,
-  normalizeAgentRecords,
   readAddressRecord,
   readOwner,
   readResolver,
@@ -225,26 +226,19 @@ export async function preflightEnsSetup(args: EnsSetupPreflightArgs): Promise<En
   }
 
   const currentAddress = isZero(childResolver) ? null : await readAddressRecord(client, resolverAddress, fullNode)
-  const currentRecords = normalizeAgentRecords(isZero(childResolver) ? {} : await readTextRecords(client, resolverAddress, fullNode))
+  const ensip25Key = buildEnsip25Key({
+    chainId: args.registry.chainId,
+    identityRegistryAddress: args.registry.identityRegistryAddress,
+    agentId: String(args.agentId),
+  })
+  const currentRecords = isZero(childResolver)
+    ? {}
+    : await readTextRecords(client, resolverAddress, fullNode, [ensip25Key, AGENT_TOKEN_RECORD_KEY])
   const nextRecords = buildAgentEnsRecords({
     chainId: args.registry.chainId,
     identityRegistryAddress: args.registry.identityRegistryAddress,
     agentId: String(args.agentId),
   })
-  if (currentRecords.token && nextRecords.token && currentRecords.token !== nextRecords.token) {
-    return manual(args, {
-      rootName,
-      label,
-      fullName,
-      operatorAddress,
-      ownerAddress,
-      resolverAddress,
-      reason: 'token-record-collision',
-      detail: `${fullName} already points to another ERC-8004 token`,
-      currentRecords,
-      nextRecords,
-    })
-  }
 
   const recordDiffs = diffRecords(currentRecords, nextRecords)
   const addressChanged = !currentAddress || !sameAddress(currentAddress, ownerAddress)

package/src/identity/ens/ensAutomation/types.ts

@@ -56,7 +56,6 @@ export type EnsSetupBlockedPlan = {
     | 'operator-matches-owner'
     | 'token-owner-mismatch'
     | 'token-owner-lookup-failed'
-    | 'token-record-collision'
     | 'lookup-failed'
   detail: string
   currentRecords?: AgentEnsRecordState

package/src/identity/ens/ensAutomation.ts

@@ -24,6 +24,7 @@ export {
   encodeEnsRecordsTransaction,
   encodeEnsRegistryTransaction,
 } from './ensAutomation/transactions.js'
+export { readAddressRecord } from './ensAutomation/read.js'
 export { isRootEthName } from './ensAutomation/names.js'
 export { preflightDeleteSubdomain } from './ensAutomation/delete.js'
 export { compareOperatorSets } from './ensAutomation/operators.js'

package/src/identity/ens/ensLookup/records.ts

@@ -11,7 +11,7 @@ export type EncodedEnsRecordTransaction = {
   calls: Hex[]
 }
 
-export async function encodeSetEthagentTextRecords(
+export async function encodeSetEnsip25TextRecord(
   fullName: string,
   records: Record<string, string>,
   opts: DiscoverOptions = {},

package/src/identity/ens/ensLookup.ts

@@ -16,4 +16,4 @@ export { resolveEnsAddress, readEthagentTextRecords, readResolverAddress } from
 export { parseAgentTokenReference } from './ensLookup/tokenReference.js'
 export { discoverOwnedEnsNameDetails, discoverOwnedEnsNames } from './ensLookup/discovery.js'
 export { validateAgentEnsLink } from './ensLookup/validation.js'
-export { encodeSetEthagentTextRecords } from './ensLookup/records.js'
+export { encodeSetEnsip25TextRecord } from './ensLookup/records.js'

package/src/identity/ens/erc7930.ts

@@ -0,0 +1,48 @@
+import type { Address } from 'viem'
+
+const VERSION = 1
+const CHAIN_TYPE_EIP155 = 0
+const ADDRESS_BYTE_LENGTH = 20
+
+export type InteroperableAddressArgs = {
+  chainId: number
+  address: Address
+}
+
+export function encodeInteroperableAddress(args: InteroperableAddressArgs): `0x${string}` {
+  if (!Number.isInteger(args.chainId) || args.chainId <= 0) {
+    throw new Error(`invalid chainId for ERC-7930: ${args.chainId}`)
+  }
+  const addressHex = args.address.toLowerCase().replace(/^0x/, '')
+  if (!/^[0-9a-f]{40}$/.test(addressHex)) {
+    throw new Error(`invalid address for ERC-7930: ${args.address}`)
+  }
+  const chainRefBytes = minimalBigEndianBytes(BigInt(args.chainId))
+  if (chainRefBytes.length > 0xff) {
+    throw new Error(`chainId too large for ERC-7930 single-byte length prefix: ${args.chainId}`)
+  }
+  return `0x${uint16Hex(VERSION)}${uint16Hex(CHAIN_TYPE_EIP155)}${uint8Hex(chainRefBytes.length)}${bytesHex(chainRefBytes)}${uint8Hex(ADDRESS_BYTE_LENGTH)}${addressHex}` as `0x${string}`
+}
+
+function uint16Hex(n: number): string {
+  return n.toString(16).padStart(4, '0')
+}
+
+function uint8Hex(n: number): string {
+  return n.toString(16).padStart(2, '0')
+}
+
+function minimalBigEndianBytes(value: bigint): Uint8Array {
+  if (value === 0n) return new Uint8Array([0])
+  const bytes: number[] = []
+  let remaining = value
+  while (remaining > 0n) {
+    bytes.unshift(Number(remaining & 0xffn))
+    remaining >>= 8n
+  }
+  return new Uint8Array(bytes)
+}
+
+function bytesHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')
+}

package/src/identity/hub/OperationalRoutes.tsx

@@ -9,6 +9,7 @@ import {
   runPublicProfileStorageSubmit,
 } from './profile/effects.js'
 import { resolveVaultAddress } from './custody/transactions.js'
+import { readCustodyMode } from './custody/state.js'
 import { WalletApprovalScreen } from './shared/components/WalletApprovalScreen.js'
 import { RebackupStorageScreen } from './continuity/RebackupStorageScreen.js'
 import { BusyScreen } from './shared/components/BusyScreen.js'
@@ -321,12 +322,14 @@ export const IdentityHubOperationalRoutes: React.FC<IdentityHubOperationalRoutes
 
   if (step.kind === 'rebackup-signing') {
     const approval = rebackupWalletApprovalView(step.identity, step.profileUpdates)
+    const vaultRouted = Boolean(step.vaultAddress)
+      && readCustodyMode(step.identity.state as Record<string, unknown> | undefined) === 'advanced'
     return (
       <WalletApprovalScreen
         title={approval.title}
         subtitle={custodyFlow.renderRebackupSubtitle(
           approval.subtitle,
-          Boolean(step.vaultAddress),
+          vaultRouted,
         )}
         walletSession={walletSession}
         label={approval.label}