ethagent 2.0.1 → 2.1.0

package/src/identity/hub/flows/custody/custodyEffects.ts

@@ -4,32 +4,32 @@ import {
   encodeDepositAgent,
   encodeUnwrapAgent,
   isAgentInVault,
-  resolveConfiguredOperatorVaultAddress,
-  OPERATOR_VAULT_ABI,
-  OPERATOR_VAULT_DEPLOY_BYTECODE,
+  resolveConfiguredVaultAddress,
+  VAULT_ABI,
+  VAULT_DEPLOY_BYTECODE,
   assertVaultBytecode,
-} from '../../../registry/operatorVault.js'
+} from '../../../registry/vault.js'
 import {
   createErc8004PublicClient,
   type Erc8004RegistryConfig,
 } from '../../../registry/erc8004.js'
 import type { EthagentIdentity } from '../../../../storage/config.js'
-import { readOperatorVaultAddressField, readOwnerAddressField } from '../../../identityCompat.js'
+import { readVaultAddressField, readOwnerAddressField } from '../../../identityCompat.js'
 import { prepareTransactionGasFee, sendBrowserWalletTransaction } from '../../../wallet/browserWallet.js'
 import { acquireTxGuard, releaseTxGuard, type TxGuardKind } from '../../txGuard.js'
 import { awaitConfirmedReceipt } from '../../effects/receipts.js'
 import type { EffectCallbacks } from '../../effects/types.js'
 import { readCustodyMode } from '../../model/custody.js'
 
-export function resolveOperatorVaultAddress(
+export function resolveVaultAddress(
   identity: EthagentIdentity,
   operatorVaults?: Readonly<Record<string, string>>,
 ): Address | undefined {
-  const identityVault = readOperatorVaultAddressField(identity.state as Record<string, unknown> | undefined)
+  const identityVault = readVaultAddressField(identity.state as Record<string, unknown> | undefined)
   if (identityVault) return getAddress(identityVault)
   if (readCustodyMode(identity.state as Record<string, unknown> | undefined) !== 'advanced') return undefined
   if (!identity.chainId) return undefined
-  return resolveConfiguredOperatorVaultAddress(operatorVaults, identity.chainId)
+  return resolveConfiguredVaultAddress(operatorVaults, identity.chainId)
 }
 
 async function withTxGuard<T>(kind: TxGuardKind, fn: () => Promise<T>): Promise<T> {
@@ -63,8 +63,8 @@ async function runVaultDeployTransactionInner(args: {
   const walletAddress = getAddress(args.walletAddress)
   const registryAddress = getAddress(args.registry.identityRegistryAddress)
   const deployData = encodeDeployData({
-    abi: OPERATOR_VAULT_ABI,
-    bytecode: OPERATOR_VAULT_DEPLOY_BYTECODE,
+    abi: VAULT_ABI,
+    bytecode: VAULT_DEPLOY_BYTECODE,
     args: [registryAddress, args.agentId],
   })
   const gasFeeClient = createErc8004PublicClient(args.registry)
@@ -86,9 +86,9 @@ async function runVaultDeployTransactionInner(args: {
   })
   args.callbacks.onWalletReady(null)
   const client = args.publicClient ?? createErc8004PublicClient(args.registry)
-  const receipt = await awaitConfirmedReceipt(client, result.txHash, 'Operator delegation vault deploy', { kind: 'vault-deploy', chainId: args.registry.chainId })
+  const receipt = await awaitConfirmedReceipt(client, result.txHash, 'Vault deploy', { kind: 'vault-deploy', chainId: args.registry.chainId })
   if (!receipt.contractAddress) {
-    throw new Error('Operator delegation vault deploy receipt is missing contractAddress; the transaction was not a contract creation')
+    throw new Error('Vault deploy receipt is missing contractAddress; the transaction was not a contract creation')
   }
   const vaultAddress = getAddress(receipt.contractAddress)
   await assertVaultBytecode(client, vaultAddress, result.txHash)
@@ -114,7 +114,7 @@ async function runVaultDepositTransactionInner(args: {
 }): Promise<{ txHash: string }> {
   const { identity, registry, vaultAddress } = args
   if (!identity.agentId) {
-    throw new Error('Cannot deposit token to operator delegation vault: agent token ID is missing')
+    throw new Error('Cannot deposit token to Vault: agent token ID is missing')
   }
   const tokenOwner = getAddress(identity.ownerAddress ?? identity.address)
   await assertVaultCanAcceptAgent({
@@ -152,7 +152,7 @@ async function runVaultDepositTransactionInner(args: {
   await awaitConfirmedReceipt(
     depositClient,
     result.txHash as Hex,
-    'Operator delegation vault deposit',
+    'Vault deposit',
     { kind: 'vault-deposit', chainId: registry.chainId },
   )
   return { txHash: result.txHash }
@@ -168,7 +168,7 @@ async function assertVaultCanAcceptAgent(args: {
   try {
     held = await client.readContract({
       address: getAddress(args.vaultAddress),
-      abi: OPERATOR_VAULT_ABI,
+      abi: VAULT_ABI,
       functionName: 'heldAgent',
     }) as readonly [Address, bigint, Address]
   } catch {
@@ -179,9 +179,9 @@ async function assertVaultCanAcceptAgent(args: {
   const expectedRegistry = getAddress(args.registry.identityRegistryAddress)
   const sameAgent = heldRegistry.toLowerCase() === expectedRegistry.toLowerCase() && heldAgentId === args.agentId
   if (sameAgent) {
-    throw new Error(`Agent vault ${getAddress(args.vaultAddress)} already holds ERC-8004 token #${args.agentId.toString()}. Publish the pending update instead of depositing again.`)
+    throw new Error(`Vault ${getAddress(args.vaultAddress)} already holds ERC-8004 token #${args.agentId.toString()}. Publish the pending update instead of depositing again.`)
   }
-  throw new Error(`Agent vault ${getAddress(args.vaultAddress)} already holds ERC-8004 token #${heldAgentId.toString()} for registry ${getAddress(heldRegistry)}. Deploy a fresh vault for this agent.`)
+  throw new Error(`Vault ${getAddress(args.vaultAddress)} already holds ERC-8004 token #${heldAgentId.toString()} for registry ${getAddress(heldRegistry)}. Deploy a fresh vault for this agent.`)
 }
 
 export async function runVaultUnwrapTransaction(args: {
@@ -206,7 +206,7 @@ async function runVaultUnwrapTransactionInner(args: {
   const { identity, registry, vaultAddress } = args
   const targetAgentId = args.agentId ?? (identity.agentId ? BigInt(identity.agentId) : undefined)
   if (targetAgentId === undefined) {
-    throw new Error('Cannot unwrap token from operator delegation vault: agent token ID is missing')
+    throw new Error('Cannot unwrap token from Vault: agent token ID is missing')
   }
   const baseState = (identity.state ?? {}) as Record<string, unknown>
   const ownerAddressRaw = readOwnerAddressField(baseState)
@@ -240,7 +240,7 @@ async function runVaultUnwrapTransactionInner(args: {
   await awaitConfirmedReceipt(
     publicClient,
     result.txHash as Hex,
-    'Operator delegation vault unwrap',
+    'Vault unwrap',
     { kind: 'vault-unwrap', chainId: registry.chainId },
   )
   await confirmAgentWithdrawnFromVault({
@@ -307,7 +307,7 @@ async function runVaultWithdrawTransactionInner(args: {
   await awaitConfirmedReceipt(
     publicClient,
     result.txHash as Hex,
-    'Operator delegation vault withdraw',
+    'Vault withdraw',
     { kind: 'vault-withdraw', chainId: registry.chainId },
   )
   await confirmAgentWithdrawnFromVault({

package/src/identity/hub/flows/custody/custodyFlowActions.ts

@@ -1,9 +1,9 @@
 import type { Address } from 'viem'
 import { createErc8004PublicClient } from '../../../registry/erc8004.js'
-import { discoverPriorVaultFromTokenOwner, isAgentInVault } from '../../../registry/operatorVault.js'
+import { discoverPriorVaultFromTokenOwner, isAgentInVault } from '../../../registry/vault.js'
 import type { ProfileUpdates, Step } from '../../identityHubReducer.js'
 import { isCustodyEditStep } from './CustodyEditFlow.js'
-import { resolveOperatorVaultAddress } from './custodyEffects.js'
+import { resolveVaultAddress } from './custodyEffects.js'
 import type { CustodyFlowDeps } from './custodyFlowTypes.js'
 import { humanOwnerAddress } from './custodyFlowHelpers.js'
 
@@ -21,7 +21,7 @@ export function createCustodyFlowActions({
 } {
   const beginVaultDeposit = (currentStep: Step, returnTo: Step, profileUpdates: ProfileUpdates): void => {
     if (!isCustodyEditStep(currentStep) || currentStep.kind !== 'custody-advanced-confirm') return
-    const vaultAddress = resolveOperatorVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
+    const vaultAddress = resolveVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
     const expectedOwnerForDiscovery = humanOwnerAddress(currentStep.identity)
     if (!vaultAddress) {
       const registry = currentStep.registry
@@ -49,7 +49,7 @@ export function createCustodyFlowActions({
             }
             if (status.inVault) {
               handleStepError(
-                new Error(`Recovered operator delegation vault ${recoveredVault} holds the token, but the vault-level depositor is ${status.ownerAddress ?? 'unknown'}, not your wallet ${expectedOwnerForDiscovery}. Mid-flow recovery requires the original depositor's wallet to call vault.unwrap.`),
+                new Error(`Recovered Vault ${recoveredVault} holds the token, but the vault-level depositor is ${status.ownerAddress ?? 'unknown'}, not your wallet ${expectedOwnerForDiscovery}. Mid-flow recovery requires the original depositor's wallet to call vault.unwrap.`),
                 { kind: 'custody-model', identity: currentStep.identity, registry, returnTo },
               )
               return
@@ -95,7 +95,7 @@ export function createCustodyFlowActions({
         }
         if (status.inVault) {
           handleStepError(
-            new Error(`Token is held by the operator delegation vault, but the vault-level owner is ${status.ownerAddress ?? 'unknown'}, not your wallet ${expectedOwner}. Recovery requires that wallet to call vault.unwrap.`),
+            new Error(`Token is held by the Vault, but the vault-level owner is ${status.ownerAddress ?? 'unknown'}, not your wallet ${expectedOwner}. Recovery requires that wallet to call vault.unwrap.`),
             { kind: 'custody-model', identity: currentStep.identity, registry, returnTo },
           )
           return
@@ -124,10 +124,10 @@ export function createCustodyFlowActions({
 
   const beginWithdrawToken = (currentStep: Step, returnTo: Step): void => {
     if (!isCustodyEditStep(currentStep)) return
-    const vaultAddress = resolveOperatorVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
+    const vaultAddress = resolveVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
     if (!vaultAddress) {
       handleStepError(
-        new Error('No agent vault is recorded for this identity. There is nothing to withdraw.'),
+        new Error('No Vault is recorded for this identity. There is nothing to withdraw.'),
         { kind: 'custody-model', identity: currentStep.identity, registry: currentStep.registry, returnTo },
       )
       return
@@ -160,7 +160,7 @@ export function createCustodyFlowActions({
         if (status.inVault) {
           if (status.ownerAddress && status.ownerAddress.toLowerCase() !== depositor.toLowerCase()) {
             handleStepError(
-              new Error(`Agent vault holds token #${activeAgentId} but recorded the depositor as ${status.ownerAddress}, not your wallet ${depositor}. Only the original depositor can withdraw.`),
+              new Error(`Vault holds token #${activeAgentId} but recorded the depositor as ${status.ownerAddress}, not your wallet ${depositor}. Only the original depositor can withdraw.`),
               { kind: 'custody-model', identity: currentStep.identity, registry: currentStep.registry, returnTo },
             )
             return
@@ -176,7 +176,7 @@ export function createCustodyFlowActions({
           return
         }
         handleStepError(
-          new Error(`Token #${activeAgentId} is not currently in the agent vault. There is nothing to withdraw; the token is already with the owner wallet.`),
+          new Error(`Token #${activeAgentId} is not currently in the Vault. There is nothing to withdraw; the token is already with the owner wallet.`),
           { kind: 'custody-model', identity: currentStep.identity, registry: currentStep.registry, returnTo },
         )
       } catch (err: unknown) {
@@ -187,7 +187,7 @@ export function createCustodyFlowActions({
 
   const beginVaultUnwrap = (currentStep: Step, returnTo: Step, profileUpdates: ProfileUpdates): void => {
     if (!isCustodyEditStep(currentStep) || currentStep.kind !== 'custody-simple-confirm') return
-    const vaultAddress = resolveOperatorVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
+    const vaultAddress = resolveVaultAddress(currentStep.identity, config?.erc8004?.operatorVaults)
     if (!vaultAddress) {
       triggerRebackup(returnTo, profileUpdates, { useVault: false })
       return

package/src/identity/hub/flows/custody/custodyFlowEffects.ts

@@ -1,6 +1,6 @@
 import { useEffect } from 'react'
 import { createErc8004PublicClient } from '../../../registry/erc8004.js'
-import { confirmAgentInVault } from '../../../registry/operatorVault.js'
+import { confirmAgentInVault } from '../../../registry/vault.js'
 import { invalidateOwnershipCache } from '../../reconciliation/index.js'
 import type { ProfileUpdates } from '../../identityHubReducer.js'
 import type { CustodyFlowDeps } from './custodyFlowTypes.js'
@@ -25,7 +25,7 @@ export function useCustodyTransactionEffects({
     let cancelled = false
     if (!step.identity.agentId) {
       handleStepError(
-        new Error('Cannot deploy agent vault: agent token ID is missing'),
+        new Error('Cannot deploy Vault: agent token ID is missing'),
         { kind: 'custody-model', identity: step.identity, registry: step.registry, returnTo: step.returnTo },
       )
       return () => { cancelled = true }

package/src/identity/hub/flows/custody/custodyFlowRoutes.tsx

@@ -24,8 +24,8 @@ export function renderCustodyStep({
   if (step.kind === 'custody-vault-deploy-tx') {
     return (
       <WalletApprovalScreen
-        title="Deploy Operator Delegation Vault"
-        subtitle={`Deploying a dedicated OperatorVault for this ERC-8004 token on ${chainLabel(step.registry.chainId)}.`}
+        title="Deploy Vault"
+        subtitle={`Deploying a dedicated Vault for this ERC-8004 token on ${chainLabel(step.registry.chainId)}.`}
         walletSession={walletSession}
         label="waiting for owner wallet transaction..."
         onCancel={() => setStep({ kind: 'custody-model', identity: step.identity, registry: step.registry, returnTo: step.returnTo })}
@@ -35,8 +35,8 @@ export function renderCustodyStep({
   if (step.kind === 'custody-vault-deposit-tx') {
     return (
       <WalletApprovalScreen
-        title="Deposit Token Into Operator Delegation Vault"
-        subtitle={`Sign one ${chainLabel(step.registry.chainId)} transaction. Sends ERC-8004 token #${step.identity.agentId ?? ''} to its agent vault.`}
+        title="Deposit Token Into Vault"
+        subtitle={`Sign one ${chainLabel(step.registry.chainId)} transaction. Sends ERC-8004 token #${step.identity.agentId ?? ''} to its Vault.`}
         walletSession={walletSession}
         label="waiting for token-owner wallet transaction..."
         onCancel={() => setStep({ kind: 'custody-model', identity: step.identity, registry: step.registry, returnTo: step.returnTo })}
@@ -49,8 +49,8 @@ export function renderCustodyStep({
       <Surface
         title="Checking Vault"
         subtitle={targetAgentId
-          ? `Confirming the agent vault holds ERC-8004 token #${targetAgentId} on ${chainLabel(step.registry.chainId)}.`
-          : `Checking this identity's recorded agent vault on ${chainLabel(step.registry.chainId)}.`}
+          ? `Confirming the Vault holds ERC-8004 token #${targetAgentId} on ${chainLabel(step.registry.chainId)}.`
+          : `Checking this identity's recorded Vault on ${chainLabel(step.registry.chainId)}.`}
         footer={<Text color={theme.dim}>esc cancel</Text>}
       >
         <Box marginTop={1}>
@@ -64,7 +64,7 @@ export function renderCustodyStep({
     return (
       <WalletApprovalScreen
         title="Withdraw Token"
-        subtitle={`Unwraps ERC-8004 token #${targetAgentId} from its agent vault to your owner wallet on ${chainLabel(step.registry.chainId)}.`}
+        subtitle={`Unwraps ERC-8004 token #${targetAgentId} from its Vault to your owner wallet on ${chainLabel(step.registry.chainId)}.`}
         walletSession={walletSession}
         label="waiting for owner wallet transaction..."
         onCancel={() => setStep({ kind: 'custody-model', identity: step.identity, registry: step.registry, returnTo: step.returnTo })}
@@ -135,7 +135,7 @@ export function renderCustodyStep({
     return (
       <Surface
         title="Token Returned to Owner Wallet"
-        subtitle={`Token returned to ${shortAddress(step.recipient)} on ${chainLabel(step.registry.chainId)}. The agent vault can be reused for this token.`}
+        subtitle={`Token returned to ${shortAddress(step.recipient)} on ${chainLabel(step.registry.chainId)}. The Vault can be reused for this token.`}
         footer={<Text color={theme.dim}>enter select · esc back</Text>}
       >
         <Box flexDirection="column">
@@ -149,7 +149,7 @@ export function renderCustodyStep({
           <Select<'return-to-vault' | 'keep-out'>
             options={[
               { value: 'return-to-vault', role: 'section', label: 'Resume Advanced Custody' },
-              { value: 'return-to-vault', label: 'Return Token to Vault', hint: 'Redeposit to this agent vault. No redeploy, no operator re-add' },
+              { value: 'return-to-vault', label: 'Return Token to Vault', hint: 'Redeposit to this Vault. No redeploy, no operator re-add' },
               { value: 'keep-out', role: 'section', label: 'Later' },
               { value: 'keep-out', label: 'Keep Out For Now', hint: 'Token stays with the owner wallet; redeposit any time from Custody Mode', role: 'utility' },
             ]}
@@ -167,8 +167,8 @@ export function renderCustodyStep({
   if (step.kind === 'custody-vault-unwrap-tx') {
     return (
       <WalletApprovalScreen
-        title="Unwrap Token From Agent Vault"
-        subtitle={`Sign one ${chainLabel(step.registry.chainId)} transaction. Calls the agent vault's unwrap function to return ERC-8004 token #${step.identity.agentId ?? ''} to the owner wallet.`}
+        title="Unwrap Token From Vault"
+        subtitle={`Sign one ${chainLabel(step.registry.chainId)} transaction. Calls the Vault unwrap function to return ERC-8004 token #${step.identity.agentId ?? ''} to the owner wallet.`}
         walletSession={walletSession}
         label="waiting for owner wallet transaction..."
         onCancel={() => setStep({ kind: 'custody-model', identity: step.identity, registry: step.registry, returnTo: step.returnTo })}
@@ -182,11 +182,11 @@ export function renderCustodyStep({
     return (
       <Surface
         title="Advanced Custody Active"
-        subtitle="Your token is held in its own OperatorVault. Authorized operator wallets can rotate the agent URI onchain without owner signatures."
+        subtitle="Your token is held in its own Vault. Authorized operator wallets can rotate the agent URI onchain without owner signatures."
         footer={<Text color={theme.dim}>enter continues</Text>}
       >
         <Box flexDirection="column">
-          {step.vaultAddress ? <Row label="Agent Vault" value={shortAddress(step.vaultAddress)} /> : null}
+          {step.vaultAddress ? <Row label="Vault" value={shortAddress(step.vaultAddress)} /> : null}
           <Row label="Owner Wallet" value={shortAddress(ownerWallet)} />
           <Row label="Operator Wallets" value={operatorCount === 1 ? '1 approved' : `${operatorCount} approved`} />
           <Box marginTop={1}>
@@ -235,5 +235,5 @@ export function renderRebackupSubtitle(
   vaultRouted: boolean,
 ): React.ReactNode {
   if (!vaultRouted) return defaultSubtitle
-  return <Text color={theme.textSubtle}>{defaultSubtitle} Routed through this token's agent vault.</Text>
+  return <Text color={theme.textSubtle}>{defaultSubtitle} Routed through this token's Vault.</Text>
 }

package/src/identity/hub/flows/ens/EnsEditAdvancedScreens.tsx

@@ -89,7 +89,7 @@ export function renderAdvancedEnsPhase({
           <Box marginTop={1} flexDirection="column">
             <EnsSetupRow label="Owner wallet" value={`Holds ERC-8004 token #${agentId ?? 'unknown'} and signs ENS records.`} />
             <EnsSetupRow label="Operator wallet" value="Restores snapshots; never controls the token." />
-            <EnsSetupRow label="Token moves" value="If the token is in the operator delegation vault, withdraw it first from Custody Mode." />
+            <EnsSetupRow label="Token moves" value="If the token is in the Vault, withdraw it first from Custody Mode." />
           </Box>
         </Box>
         <Box marginTop={1}>
@@ -217,7 +217,7 @@ export function renderAdvancedEnsPhase({
         <Box flexDirection="column">
           <Text color={theme.dim}>Agent ENS: <Text color={theme.text}>{label}.{rootName}</Text></Text>
           {phase.registryAction ? <Text color={theme.dim}>{advancedSubdomainStatusText(phase.registryAction)}</Text> : null}
-          <Text color={theme.dim}>Choose the operator wallet for snapshot restore access and onchain ERC-8004 URI rotation via the operator delegation vault.</Text>
+          <Text color={theme.dim}>Choose the operator wallet for snapshot restore access and onchain ERC-8004 URI rotation via the Vault.</Text>
           <Text color={theme.dim}>The operator wallet has no authority over this ENS subdomain or any token transfer; the owner wallet is the sole signer for both.</Text>
           <Text color={theme.dim}>We only read the operator's address here so it can be added to the snapshot envelope and vault operator list later.</Text>
           {savedOperator ? <Text color={theme.dim}>Saved operator wallet: <Text color={theme.text}>{shortAddress(savedOperator)}</Text></Text> : null}

package/src/identity/hub/flows/ens/EnsEditReviewScreens.tsx

@@ -218,9 +218,9 @@ export const EnsSetupBlockedScreen: React.FC<EnsSetupBlockedScreenProps> = ({
             ? (
               <>
                 <Box marginTop={1} flexDirection="column">
-                  <Text color={theme.text}>To proceed: the owner wallet signs ENS records and must hold this token at setup time. Once setup is done you can deposit the token into the operator delegation vault while the ENS subdomain stays with the owner wallet.</Text>
+                  <Text color={theme.text}>To proceed: the owner wallet signs ENS records and must hold this token at setup time. Once setup is done you can deposit the token into the Vault while the ENS subdomain stays with the owner wallet.</Text>
                 </Box>
-                <Text color={theme.dim}>Operator wallets have no authority on this name; they only rotate the onchain ERC-8004 URI via the operator delegation vault.</Text>
+                <Text color={theme.dim}>Operator wallets have no authority on this name; they only rotate the onchain ERC-8004 URI via the Vault.</Text>
               </>
               )
             : null}

package/src/identity/hub/model/copy.ts

@@ -21,7 +21,7 @@ export function copyableIdentityFields(identity?: EthagentIdentity, config?: Eth
   const custodyMode = readCustodyMode(identity.state)
   if (custodyMode === 'advanced') {
     const vaultAddress = readIdentityStateString(identity.state, 'operatorVaultAddress')
-    if (vaultAddress) fields.push({ label: 'Agent Vault', value: vaultAddress })
+    if (vaultAddress) fields.push({ label: 'Vault', value: vaultAddress })
   }
   const activeOperator = readIdentityStateString(identity.state, 'activeOperatorAddress')
   if (activeOperator) fields.push({ label: 'Operator Wallet', value: activeOperator })

package/src/identity/hub/model/errors.ts

@@ -6,9 +6,9 @@ import {
   ContinuityTransferSnapshotTargetMismatchError,
 } from '../../continuity/envelope.js'
 import {
-  OperatorVaultBytecodeMismatchError,
-  formatOperatorVaultBytecodeMismatchDetail,
-} from '../../registry/operatorVault.js'
+  VaultBytecodeMismatchError,
+  formatVaultBytecodeMismatchDetail,
+} from '../../registry/vault.js'
 import { BrowserWalletError } from '../../wallet/browserWallet.js'
 import { TxGuardBusyError } from '../txGuard.js'
 import { shortAddress } from './format.js'
@@ -65,11 +65,11 @@ export function identityHubErrorView(err: unknown): IdentityHubErrorView {
       hint: `Prepare a new transfer snapshot from ${shortAddress(err.snapshotOwner)} to the intended receiver wallet.`,
     }
   }
-  if (err instanceof OperatorVaultBytecodeMismatchError) {
+  if (err instanceof VaultBytecodeMismatchError) {
     return {
       title: 'Vault Bytecode Mismatch',
-      detail: formatOperatorVaultBytecodeMismatchDetail(err),
-      hint: 'Open the deploy tx on the block explorer and confirm the input data matches the OperatorVault deploy bytecode plus constructor args before retrying. A persistent mismatch usually means the wallet or RPC substituted the create.',
+      detail: formatVaultBytecodeMismatchDetail(err),
+      hint: 'Open the deploy tx on the block explorer and confirm the input data matches the Vault deploy bytecode plus constructor args before retrying. A persistent mismatch usually means the wallet or RPC substituted the create.',
     }
   }
   if (err instanceof BrowserWalletError) {

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

@@ -85,7 +85,7 @@ async function runOwnershipPreflight(args: {
       return {
         ok: false,
         reason: 'not-owned',
-        detail: `Token is held by the operator delegation vault (${directOwner.owner}). Withdraw it first.`,
+        detail: `Token is held by the Vault (${directOwner.owner}). Withdraw it first.`,
         onChainOwner: directOwner.owner,
       }
     }

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

@@ -5,9 +5,9 @@ import {
   validateErc8004TokenOwner,
   type Erc8004RegistryConfig,
 } from '../../../registry/erc8004.js'
-import { isAgentInVault, resolveConfiguredOperatorVaultAddress } from '../../../registry/operatorVault.js'
+import { isAgentInVault, resolveConfiguredVaultAddress } from '../../../registry/vault.js'
 import type { EthagentConfig, EthagentIdentity } from '../../../../storage/config.js'
-import { readOperatorVaultAddressField } from '../../../identityCompat.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'
@@ -115,11 +115,11 @@ function resolveReconciliationVaultAddress(
   identity: EthagentIdentity,
   operatorVaults?: Readonly<Record<string, string>>,
 ): Address | undefined {
-  const identityVault = readOperatorVaultAddressField(identity.state as Record<string, unknown> | undefined)
+  const identityVault = readVaultAddressField(identity.state as Record<string, unknown> | undefined)
   if (identityVault) return getAddress(identityVault)
   if (readCustodyMode(identity.state as Record<string, unknown> | undefined) !== 'advanced') return undefined
   if (!identity.chainId) return undefined
-  return resolveConfiguredOperatorVaultAddress(operatorVaults, identity.chainId)
+  return resolveConfiguredVaultAddress(operatorVaults, identity.chainId)
 }
 
 type TokenProbe =

package/src/identity/hub/useIdentityHubController.ts

@@ -24,7 +24,7 @@ import type {
   RestoreProgress,
   TokenTransferProgress,
 } from './effects/types.js'
-import { resolveOperatorVaultAddress } from './flows/custody/custodyEffects.js'
+import { resolveVaultAddress } from './flows/custody/custodyEffects.js'
 import { useCustodyFlow } from './flows/custody/useCustodyFlow.js'
 import { identityHubErrorView } from './model/errors.js'
 import { readCustodyMode } from './model/custody.js'
@@ -242,7 +242,7 @@ export function useIdentityHubController({
     }
     const vaultAddress = options?.useVault === false
       ? undefined
-      : options?.vaultAddress ?? resolveOperatorVaultAddress(identity, config?.erc8004?.operatorVaults)
+      : options?.vaultAddress ?? resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
     ;(async () => {
       const role: 'token-holder' | 'vault-level-owner' = vaultAddress ? 'vault-level-owner' : 'token-holder'
       const allowed = await guardOwnership(identity, registry, role, backStep)
@@ -260,7 +260,7 @@ export function useIdentityHubController({
       return
     }
     ;(async () => {
-      const vaultAddress = resolveOperatorVaultAddress(identity, config?.erc8004?.operatorVaults)
+      const vaultAddress = resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
       const allowed = await guardOwnership(identity, registry, 'vault-level-owner', backStep)
       if (!allowed) return
       runPublicProfilePreflight(identity, registry, callbacks, profileUpdates, backStep, vaultAddress)

package/src/identity/identityCompat.ts

@@ -17,15 +17,15 @@ export function clearOwnerAddressField(target: Record<string, unknown>): void {
   delete target[LEGACY_OWNER_ADDRESS_KEY]
 }
 
-export function readOperatorVaultAddressField(input: Record<string, unknown> | null | undefined): string | undefined {
+export function readVaultAddressField(input: Record<string, unknown> | null | undefined): string | undefined {
   return stringValue(input?.[OPERATOR_VAULT_ADDRESS_KEY])
 }
 
-export function setOperatorVaultAddressField(target: Record<string, unknown>, value: string): void {
+export function setVaultAddressField(target: Record<string, unknown>, value: string): void {
   target[OPERATOR_VAULT_ADDRESS_KEY] = value
 }
 
-export function clearOperatorVaultAddressField(target: Record<string, unknown>): void {
+export function clearVaultAddressField(target: Record<string, unknown>): void {
   delete target[OPERATOR_VAULT_ADDRESS_KEY]
 }
 

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

@@ -1,7 +1,7 @@
 import { getAddress, isAddress, type Address, type PublicClient } from 'viem'
 import { mainnet } from 'viem/chains'
 import { DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
-import { isAgentInVault } from '../operatorVault.js'
+import { isAgentInVault } from '../vault.js'
 import { ERC8004_ABI, TRANSFER_EVENT } from './abi.js'
 import {
   SUPPORTED_ERC8004_CHAINS,

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

@@ -1,5 +1,5 @@
 import { getAddress, type Address, type PublicClient } from 'viem'
-import { OPERATOR_VAULT_ABI } from '../operatorVault.js'
+import { VAULT_ABI } from '../vault.js'
 import { ERC8004_ABI } from './abi.js'
 import { createErc8004PublicClient } from './client.js'
 import type { Erc8004RegistryConfig } from './types.js'
@@ -54,7 +54,7 @@ export async function validateErc8004TokenOwner(args: Erc8004RegistryConfig & {
     return {
       ok: false,
       reason: 'token-owner-lookup-failed',
-      detail: `ERC-8004 token #${args.agentId.toString()} is still reported at the operator delegation vault, but that vault record is empty. Ownership is still settling; retry shortly.`,
+      detail: `ERC-8004 token #${args.agentId.toString()} is still reported at the Vault, but that vault record is empty. Ownership is still settling; retry shortly.`,
     }
   }
   if (vaultOwnerResult.kind === 'error') {
@@ -73,7 +73,7 @@ export async function validateErc8004TokenOwner(args: Erc8004RegistryConfig & {
       ok: false,
       reason: 'token-owner-mismatch',
       ownerAddress: vaultOwner,
-      detail: `ERC-8004 token #${args.agentId.toString()} is held by the operator delegation vault for ${vaultOwner}`,
+      detail: `ERC-8004 token #${args.agentId.toString()} is held by the Vault for ${vaultOwner}`,
     }
   }
   return {
@@ -98,7 +98,7 @@ async function readVaultLevelOwner(args: Erc8004RegistryConfig & {
     const client = args.publicClient ?? createErc8004PublicClient(args)
     const vaultOwner = await client.readContract({
       address: args.vaultAddress,
-      abi: OPERATOR_VAULT_ABI,
+      abi: VAULT_ABI,
       functionName: 'agentOwner',
       args: [args.identityRegistryAddress, args.agentId],
     }) as Address

package/src/identity/registry/{operatorVault → vault}/bytecode.ts

@@ -1,7 +1,7 @@
 import { getAddress, keccak256, type Address, type Hex, type PublicClient } from 'viem'
-import { OPERATOR_VAULT_RUNTIME_BYTECODE, OPERATOR_VAULT_RUNTIME_BYTECODE_HASH } from './constants.js'
+import { VAULT_RUNTIME_BYTECODE, VAULT_RUNTIME_BYTECODE_HASH } from './constants.js'
 
-export class OperatorVaultBytecodeMismatchError extends Error {
+export class VaultBytecodeMismatchError extends Error {
   readonly vaultAddress: Address
   readonly observedHash: Hex | null
   readonly observedLength: number
@@ -15,22 +15,22 @@ export class OperatorVaultBytecodeMismatchError extends Error {
     txHash?: Hex,
   ) {
     super(
-      'Deployed contract bytecode does not match the expected operator delegation vault. The deploy transaction may have been intercepted.',
+      'Deployed contract bytecode does not match the expected Vault. The deploy transaction may have been intercepted.',
     )
-    this.name = 'OperatorVaultBytecodeMismatchError'
+    this.name = 'VaultBytecodeMismatchError'
     this.vaultAddress = vaultAddress
     this.observedHash = observedHash
     this.observedLength = observedLength
-    this.expectedHash = OPERATOR_VAULT_RUNTIME_BYTECODE_HASH
-    this.expectedLength = (OPERATOR_VAULT_RUNTIME_BYTECODE.length - 2) / 2
+    this.expectedHash = VAULT_RUNTIME_BYTECODE_HASH
+    this.expectedLength = (VAULT_RUNTIME_BYTECODE.length - 2) / 2
     if (txHash) this.txHash = txHash
   }
 }
 
 export type AssertVaultBytecodeClient = Pick<PublicClient, 'getBytecode'>
 
-export const OPERATOR_VAULT_POLL_MAX_ATTEMPTS = 5
-export const OPERATOR_VAULT_POLL_DELAY_MS = 1500
+export const VAULT_POLL_MAX_ATTEMPTS = 5
+export const VAULT_POLL_DELAY_MS = 1500
 export function delayMs(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
@@ -41,8 +41,8 @@ async function readVaultBytecodeWithPoll(
 ): Promise<Hex | undefined> {
   let lastErr: unknown
   let lastCode: Hex | undefined
-  for (let attempt = 0; attempt < OPERATOR_VAULT_POLL_MAX_ATTEMPTS; attempt++) {
-    if (attempt > 0) await delayMs(OPERATOR_VAULT_POLL_DELAY_MS)
+  for (let attempt = 0; attempt < VAULT_POLL_MAX_ATTEMPTS; attempt++) {
+    if (attempt > 0) await delayMs(VAULT_POLL_DELAY_MS)
     try {
       const code = await client.getBytecode({ address })
       lastErr = undefined
@@ -66,13 +66,13 @@ export async function assertVaultBytecode(
   const address = getAddress(vaultAddress)
   const code = await readVaultBytecodeWithPoll(client, address)
   if (!code || code === '0x') {
-    throw new OperatorVaultBytecodeMismatchError(address, null, 0, txHash)
+    throw new VaultBytecodeMismatchError(address, null, 0, txHash)
   }
   const observedLength = (code.length - 2) / 2
   const observed = keccak256(code).toLowerCase() as Hex
-  const expected = OPERATOR_VAULT_RUNTIME_BYTECODE_HASH.toLowerCase() as Hex
+  const expected = VAULT_RUNTIME_BYTECODE_HASH.toLowerCase() as Hex
   if (observed !== expected) {
-    throw new OperatorVaultBytecodeMismatchError(address, observed, observedLength, txHash)
+    throw new VaultBytecodeMismatchError(address, observed, observedLength, txHash)
   }
 }
 
@@ -80,8 +80,8 @@ function shortHash(hash: Hex): string {
   return `${hash.slice(0, 18)}...${hash.slice(-6)}`
 }
 
-export function formatOperatorVaultBytecodeMismatchDetail(
-  err: OperatorVaultBytecodeMismatchError,
+export function formatVaultBytecodeMismatchDetail(
+  err: VaultBytecodeMismatchError,
 ): string {
   const lines = [
     `Vault address:   ${err.vaultAddress}`,