ethagent 1.1.2 → 2.0.1

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

@@ -0,0 +1,94 @@
+import type { ContinuityWorkingTreeStatus } from '../../continuity/storage.js'
+import type { EthagentIdentity } from '../../../storage/config.js'
+
+export function hasPendingPublish(identity?: EthagentIdentity): boolean {
+  if (!identity?.backup?.cid) return false
+  if (!identity.metadataCid) return false
+  if (!identity.backup.metadataCid) return true
+  return identity.backup.metadataCid !== identity.metadataCid
+}
+
+export type LocalChangeStatusView = {
+  label: string
+  detail: string
+  tone: 'ok' | 'warn' | 'dim'
+  files: string[]
+  hasLocalChanges: boolean
+}
+
+export function changedContinuitySnapshotFiles(
+  workingStatus?: ContinuityWorkingTreeStatus | null,
+): string[] {
+  if (!workingStatus?.localContentHashes || !workingStatus.publishedContentHashes) return []
+  const files: Array<keyof typeof workingStatus.localContentHashes> = ['SOUL.md', 'MEMORY.md', 'skills.json']
+  return files
+    .filter(file => workingStatus.localContentHashes?.[file] !== workingStatus.publishedContentHashes?.[file])
+    .map(displayContinuitySnapshotFile)
+}
+
+function displayContinuitySnapshotFile(file: keyof NonNullable<ContinuityWorkingTreeStatus['localContentHashes']>): string {
+  return file
+}
+
+export function localChangeStatusView(
+  workingStatus?: ContinuityWorkingTreeStatus | null,
+): LocalChangeStatusView {
+  if (!workingStatus) {
+    return {
+      label: 'Local Changes',
+      detail: '',
+      tone: 'dim',
+      files: [],
+      hasLocalChanges: false,
+    }
+  }
+
+  if (workingStatus.publishState === 'published') {
+    return {
+      label: 'Local Changes',
+      detail: 'None detected',
+      tone: 'ok',
+      files: [],
+      hasLocalChanges: false,
+    }
+  }
+
+  if (workingStatus.publishState === 'local-changes') {
+    const files = changedContinuitySnapshotFiles(workingStatus)
+    return {
+      label: 'Local Changes',
+      detail: files.length > 0 ? `Detected: ${files.join(', ')}` : 'Detected: local files differ from saved snapshot',
+      tone: 'warn',
+      files,
+      hasLocalChanges: true,
+    }
+  }
+
+  if (workingStatus.publishState === 'not-published') {
+    return {
+      label: 'Local Changes',
+      detail: 'Snapshot not saved yet',
+      tone: 'warn',
+      files: [],
+      hasLocalChanges: false,
+    }
+  }
+
+  if (workingStatus.publishState === 'verify-needed') {
+    return {
+      label: 'Local Changes',
+      detail: 'Unable to verify saved snapshot',
+      tone: 'warn',
+      files: [],
+      hasLocalChanges: false,
+    }
+  }
+
+  return {
+    label: 'Local Changes',
+    detail: 'Local files not restored',
+    tone: 'warn',
+    files: [],
+    hasLocalChanges: false,
+  }
+}

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

@@ -0,0 +1,35 @@
+import type { EthagentConfig, EthagentIdentity } from '../../../storage/config.js'
+import { readCustodyMode, readIdentityStateString } from './custody.js'
+
+type CopyableField = {
+  label: string
+  value: string
+}
+
+export function copyableIdentityFields(identity?: EthagentIdentity, config?: EthagentConfig): CopyableField[] {
+  if (!identity) return []
+  const fields: CopyableField[] = []
+  if (identity.agentId) fields.push({ label: 'Token ID', value: identity.agentId })
+  const ensName = readIdentityStateString(identity.state, 'ensName')
+  if (ensName) fields.push({ label: 'ENS Name', value: ensName })
+  const agentUri = identity.agentUri ?? (identity.metadataCid ? `ipfs://${identity.metadataCid}` : undefined)
+  if (agentUri) fields.push({ label: 'Agent URI', value: agentUri })
+  const ownerAddress = readIdentityStateString(identity.state, 'ownerAddress')
+  const owner = identity.ownerAddress ?? identity.address
+  const ownerWallet = ownerAddress || owner
+  if (ownerWallet) fields.push({ label: 'Owner Wallet', value: ownerWallet })
+  const custodyMode = readCustodyMode(identity.state)
+  if (custodyMode === 'advanced') {
+    const vaultAddress = readIdentityStateString(identity.state, 'operatorVaultAddress')
+    if (vaultAddress) fields.push({ label: 'Agent Vault', value: vaultAddress })
+  }
+  const activeOperator = readIdentityStateString(identity.state, 'activeOperatorAddress')
+  if (activeOperator) fields.push({ label: 'Operator Wallet', value: activeOperator })
+  return fields
+}
+
+export function identityValuesCopyHint(identity?: EthagentIdentity): string {
+  return readIdentityStateString(identity?.state, 'ensName')
+    ? 'Copy token, ENS, and token URI pointers'
+    : 'Copy token and token URI pointers'
+}

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

@@ -0,0 +1,54 @@
+import type { EthagentIdentity } from '../../../storage/config.js'
+import { readOwnerAddressField } from '../../identityCompat.js'
+
+export type CustodyMode = 'simple' | 'advanced'
+
+export function readCustodyMode(state: Record<string, unknown> | undefined): CustodyMode | undefined {
+  const s = (state ?? {}) as Record<string, unknown>
+  const current = s.custodyMode
+  if (current === 'simple' || current === 'advanced') return current
+  if (current === 'single') return 'simple'
+  if (current === 'multi') return 'advanced'
+  const legacy = s.ensMode
+  if (legacy === 'advanced') return 'advanced'
+  if (legacy === 'simple') return 'simple'
+  return undefined
+}
+
+export function displayCustodyMode(mode: CustodyMode | undefined): string {
+  if (mode === 'advanced') return 'Advanced'
+  if (mode === 'simple') return 'Simple'
+  return 'Not set'
+}
+
+export function identityOwnerAddress(identity?: EthagentIdentity, verifiedOnchainOwner?: string): string {
+  const onchainOwner = typeof verifiedOnchainOwner === 'string' ? verifiedOnchainOwner.trim() : ''
+  if (onchainOwner) return onchainOwner
+  if (!identity) return ''
+  return readOwnerAddressField(identity.state as Record<string, unknown> | undefined)
+    ?? identity.ownerAddress
+    ?? identity.address
+    ?? ''
+}
+
+export type IdentityPerspective = 'owner' | 'operator' | 'unknown'
+
+export function identityPerspective(identity?: EthagentIdentity): IdentityPerspective {
+  if (!identity) return 'unknown'
+  const connected = identity.connectedWallet?.toLowerCase()
+  if (!connected) return 'unknown'
+  const ownerAddress = (readOwnerAddressField(identity.state as Record<string, unknown> | undefined) ?? identity.ownerAddress ?? identity.address)?.toLowerCase()
+  if (ownerAddress && connected === ownerAddress) return 'owner'
+  const activeOp = readIdentityStateString(identity.state as Record<string, unknown> | undefined, 'activeOperatorAddress')?.toLowerCase()
+  if (activeOp && connected === activeOp) return 'operator'
+  const approvedRaw = (identity.state as Record<string, unknown> | undefined)?.approvedOperatorWallets
+  const approved = Array.isArray(approvedRaw) ? approvedRaw as Array<{ address?: unknown }> : []
+  if (approved.some(r => typeof r?.address === 'string' && r.address.toLowerCase() === connected)) return 'operator'
+  return 'unknown'
+}
+
+export function readIdentityStateString(state: Record<string, unknown> | undefined, key: string): string {
+  if (key === 'ownerAddress') return readOwnerAddressField(state) ?? ''
+  const value = state?.[key]
+  return typeof value === 'string' ? value.trim() : ''
+}

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

@@ -0,0 +1,49 @@
+import type { EthagentIdentity } from '../../../storage/config.js'
+import { readIdentityStateString } from './custody.js'
+
+export type EnsStatusView =
+  | { kind: 'none' }
+  | { kind: 'linked'; name: string }
+  | { kind: 'issue'; name: string; reason: string }
+
+type EnsValidationRecord = {
+  ok: boolean
+  reason?: string
+  resolvedAddress?: string
+  checkedAt?: string
+}
+
+function readEnsValidation(state: Record<string, unknown> | undefined): EnsValidationRecord | null {
+  const raw = state?.ensValidation
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+  const obj = raw as Record<string, unknown>
+  if (typeof obj.ok !== 'boolean') return null
+  return {
+    ok: obj.ok,
+    ...(typeof obj.reason === 'string' ? { reason: obj.reason } : {}),
+    ...(typeof obj.resolvedAddress === 'string' ? { resolvedAddress: obj.resolvedAddress } : {}),
+    ...(typeof obj.checkedAt === 'string' ? { checkedAt: obj.checkedAt } : {}),
+  }
+}
+
+export function selectEnsStatus(identity: EthagentIdentity | undefined | null): EnsStatusView {
+  if (!identity) return { kind: 'none' }
+  const name = readIdentityStateString(identity.state, 'ensName')
+  if (!name) return { kind: 'none' }
+  const validation = readEnsValidation(identity.state)
+  if (validation?.ok) return { kind: 'linked', name }
+  return { kind: 'issue', name, reason: validation?.reason ?? 'not yet verified' }
+}
+
+export function ensValidationReasonText(reason: string | undefined): string {
+  switch (reason) {
+    case 'no-owner':           return 'Name does not exist on ENS'
+    case 'no-resolver':        return 'Name has no resolver set'
+    case 'address-mismatch':   return 'ENS name is not resolving to the expected wallet'
+    case 'lookup-failed':      return 'Could not reach Ethereum mainnet'
+    case 'token-owner-mismatch': return 'Token not held by owner wallet'
+    case 'token-owner-lookup-failed': return 'Could not verify ERC-8004 token owner'
+    case undefined:            return 'Not yet verified'
+    default:                   return reason
+  }
+}

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

@@ -0,0 +1,140 @@
+import { ZodError } from 'zod'
+import { RegisterAgentPreflightError } from '../../registry/erc8004.js'
+import { AgentStateOwnerMismatchError } from '../../crypto/backupEnvelope.js'
+import {
+  ContinuitySnapshotOwnerMismatchError,
+  ContinuityTransferSnapshotTargetMismatchError,
+} from '../../continuity/envelope.js'
+import {
+  OperatorVaultBytecodeMismatchError,
+  formatOperatorVaultBytecodeMismatchDetail,
+} from '../../registry/operatorVault.js'
+import { BrowserWalletError } from '../../wallet/browserWallet.js'
+import { TxGuardBusyError } from '../txGuard.js'
+import { shortAddress } from './format.js'
+
+export type IdentityHubErrorView = {
+  title: string
+  detail?: string
+  hint?: string
+}
+
+export function identityHubErrorView(err: unknown): IdentityHubErrorView {
+  if (err instanceof ZodError) {
+    const issue = err.issues[0]
+    const path = issue?.path.join('.') ?? ''
+    const message = issue?.message ?? 'Schema validation failed.'
+    return {
+      title: 'Config Validation Failed',
+      detail: path ? `${path}: ${message}` : message,
+      hint: 'Internal: a config write was attempted before required fields were set. Restart First Run if this persists.',
+    }
+  }
+  if (err instanceof TxGuardBusyError) {
+    return {
+      title: 'Already In Progress',
+      detail: err.message,
+      hint: 'Approve or cancel the open wallet popup, then retry.',
+    }
+  }
+  if (err instanceof RegisterAgentPreflightError) {
+    return {
+      title: err.title,
+      detail: err.detail,
+      hint: err.hint,
+    }
+  }
+  if (err instanceof AgentStateOwnerMismatchError) {
+    return {
+      title: 'Backup Locked to Another Wallet',
+      detail: `Wallet ${shortAddress(err.currentOwner)} cannot read state encrypted for ${shortAddress(err.backupOwner)}.`,
+      hint: 'Use the wallet that created this backup.',
+    }
+  }
+  if (err instanceof ContinuitySnapshotOwnerMismatchError) {
+    return {
+      title: 'Snapshot Locked to Previous Wallet',
+      detail: 'This token points at an owner-only snapshot. Ask the previous owner to prepare a transfer snapshot before transferring.',
+      hint: `Current wallet ${shortAddress(err.currentOwner)} cannot read the snapshot encrypted for ${shortAddress(err.snapshotOwner)}.`,
+    }
+  }
+  if (err instanceof ContinuityTransferSnapshotTargetMismatchError) {
+    return {
+      title: 'Transfer Snapshot Receiver Mismatch',
+      detail: `This transfer snapshot is for receiver ${shortAddress(err.targetOwner)}, but the current token owner is ${shortAddress(err.currentOwner)}.`,
+      hint: `Prepare a new transfer snapshot from ${shortAddress(err.snapshotOwner)} to the intended receiver wallet.`,
+    }
+  }
+  if (err instanceof OperatorVaultBytecodeMismatchError) {
+    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.',
+    }
+  }
+  if (err instanceof BrowserWalletError) {
+    const lines: string[] = []
+    if (err.purpose) lines.push(`Action: ${err.purpose}`)
+    if (err.method) lines.push(`Method: ${err.method}`)
+    if (err.code) lines.push(`Code: ${err.code}`)
+    lines.push(`Wallet: ${err.message}`)
+    if (err.causes.length) {
+      for (const cause of err.causes) lines.push(`Caused by: ${cause}`)
+    }
+    if (err.data) lines.push(`Data: ${err.data}`)
+    return {
+      title: err.title ?? 'Wallet Error',
+      detail: lines.join('\n'),
+      hint: 'Switch to the expected wallet, confirm you have funds, then retry. If the wallet keeps reporting an internal RPC error, change the RPC endpoint in your wallet settings.',
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err)
+  if (/^owner wallet required:/i.test(message)) {
+    return {
+      title: 'Owner Wallet Required',
+      detail: capitalizeErrorText(message.replace(/^owner wallet required:\s*/i, '')),
+      hint: 'Switch to the owner wallet, then try again.',
+    }
+  }
+  if (/^operator wallet required:/i.test(message)) {
+    return {
+      title: 'Operator Wallet Required',
+      detail: capitalizeErrorText(message.replace(/^operator wallet required:\s*/i, '')),
+      hint: 'Switch to the operator wallet, then try again.',
+    }
+  }
+  if (/^Restore Slot Missing:/i.test(message)) {
+    return {
+      title: 'Wallet Not Included In Snapshot',
+      detail: 'ERC-8004 metadata authorizes this wallet, but the latest encrypted snapshot was saved before this wallet had restore access.',
+      hint: 'Use the owner wallet once to save a fresh snapshot, then restore with this wallet.',
+    }
+  }
+  if (message === 'fetch failed') {
+    return {
+      title: 'Storage Unavailable',
+      detail: 'Could not reach storage.',
+      hint: 'Check the connection, then try again.',
+    }
+  }
+  return {
+    title: 'Identity Error',
+    detail: capitalizeErrorText(message),
+  }
+}
+
+export function pinataErrorText(err: unknown): string {
+  const view = identityHubErrorView(err)
+  return view.detail ?? view.title
+}
+
+export function isRegistrationPreflightError(err: unknown): boolean {
+  return err instanceof RegisterAgentPreflightError
+}
+
+function capitalizeErrorText(value: string): string {
+  const trimmed = value.trim()
+  if (/^wallet request timed out$/i.test(trimmed)) return 'Wallet Request Timed Out'
+  if (!trimmed) return trimmed
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1)
+}

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

@@ -0,0 +1,15 @@
+export function shortCid(cid: string): string {
+  if (cid.length <= 18) return cid
+  return `${cid.slice(0, 10)}...${cid.slice(-6)}`
+}
+
+export function shortAddress(address: string): string {
+  if (address.length <= 14) return address
+  return `${address.slice(0, 6)}...${address.slice(-4)}`
+}
+
+export function formatDate(input: string): string {
+  const date = new Date(input)
+  if (Number.isNaN(date.getTime())) return input
+  return date.toISOString().slice(0, 10)
+}

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

@@ -0,0 +1,94 @@
+import type { EthagentConfig, EthagentIdentity } from '../../../storage/config.js'
+import { supportedErc8004ChainForId, type Erc8004AgentCandidate } from '../../registry/erc8004.js'
+import { readCustodyMode, type CustodyMode } from './custody.js'
+import { formatDate, shortAddress, shortCid } from './format.js'
+import { chainSummaryRow, networkLabel } from './network.js'
+
+export const PREFLIGHT_AGENT_URI = 'ipfs://bafybeigdyrztma2dbfczw7q6ooozbxlqzyw5r7w4f3qw2axvvxqg3w6y7q'
+
+export function initialAgentState(name: string, description: string, ownerAddress: string): Record<string, unknown> {
+  return {
+    version: 1,
+    name,
+    description,
+    ownerAddress,
+    custodyMode: 'simple' as CustodyMode,
+    createdAt: new Date().toISOString(),
+    preferences: {},
+    memory: {},
+  }
+}
+
+export function tokenCandidateLabel(candidate: Erc8004AgentCandidate): string {
+  return candidate.name?.trim() || `Agent Token #${candidate.agentId.toString()}`
+}
+
+export function tokenCandidateSelectLabel(
+  candidate: Erc8004AgentCandidate,
+  current = false,
+): string {
+  return `${tokenCandidateLabel(candidate)}${current ? '  *' : ''}`
+}
+
+export function tokenCandidateHint(candidate: Erc8004AgentCandidate): string {
+  const chain = supportedErc8004ChainForId(candidate.chainId)
+  const network = chain?.network ? networkLabel(chain.network) : chain?.name ?? `chain ${candidate.chainId}`
+  const parts = [
+    candidate.name?.trim() ? `token #${candidate.agentId.toString()}` : null,
+    network,
+    candidate.backup?.createdAt ? `backup ${formatDate(candidate.backup.createdAt)}` : null,
+  ].filter((part): part is string => Boolean(part))
+  return parts.join(' · ')
+}
+
+export function isCurrentAgentCandidate(
+  identity: EthagentIdentity | undefined,
+  candidate: Erc8004AgentCandidate,
+): boolean {
+  if (!identity?.agentId) return false
+  if (identity.agentId !== candidate.agentId.toString()) return false
+
+  const owner = identity.ownerAddress ?? identity.address
+  if (owner && owner.toLowerCase() !== candidate.ownerAddress.toLowerCase()) return false
+  if (identity.chainId !== undefined && identity.chainId !== candidate.chainId) return false
+  if (
+    identity.identityRegistryAddress
+    && identity.identityRegistryAddress.toLowerCase() !== candidate.identityRegistryAddress.toLowerCase()
+  ) {
+    return false
+  }
+  return true
+}
+
+export function identitySummaryRows(
+  identity: EthagentIdentity | undefined,
+  config?: EthagentConfig,
+): Array<{
+  label: string
+  value: string
+  tone: 'ok' | 'dim'
+}> {
+  const backup = identity?.backup
+  const owner = identity?.ownerAddress ?? identity?.address
+  const ownerValue = owner ? shortAddress(owner) : 'not connected'
+  const tokenValue = identity?.agentId ? `#${identity.agentId}` : 'not created'
+  const chain = chainSummaryRow(config, identity)
+  const stateValue = backup?.cid ? shortCid(backup.cid) : 'not saved yet'
+  const skillsValue = identity?.publicSkills?.cid ? shortCid(identity.publicSkills.cid) : 'not saved'
+  const cardValue = identity?.publicSkills?.agentCardCid ? shortCid(identity.publicSkills.agentCardCid) : 'not saved'
+  const iconValue = typeof identity?.state?.imageUrl === 'string' && identity.state.imageUrl.trim() ? 'attached' : 'not attached'
+  return [
+    { label: 'owner wallet', value: ownerValue, tone: identity ? 'ok' : 'dim' },
+    { label: 'token', value: tokenValue, tone: identity?.agentId ? 'ok' : 'dim' },
+    { label: 'network', value: chain.value, tone: chain.tone },
+    { label: 'state', value: stateValue, tone: backup ? 'ok' : 'dim' },
+    { label: 'skills', value: skillsValue, tone: identity?.publicSkills?.cid ? 'ok' : 'dim' },
+    { label: 'card', value: cardValue, tone: identity?.publicSkills?.agentCardCid ? 'ok' : 'dim' },
+    { label: 'icon', value: iconValue, tone: iconValue === 'attached' ? 'ok' : 'dim' },
+  ]
+}
+
+export function lastBackupLabel(identity?: EthagentIdentity): string {
+  const created = identity?.backup?.createdAt
+  return created ? formatDate(created) : 'never'
+}

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

@@ -0,0 +1,32 @@
+import type { EthagentConfig, EthagentIdentity, SelectableNetwork } from '../../../storage/config.js'
+import { supportedErc8004ChainForId } from '../../registry/erc8004.js'
+import { resolveSelectedNetwork } from '../../registry/registryConfig.js'
+
+const NETWORK_LABELS: Record<SelectableNetwork, string> = {
+  mainnet: 'ethereum mainnet',
+  base:    'base',
+}
+
+export function networkLabel(network: SelectableNetwork): string {
+  return NETWORK_LABELS[network]
+}
+
+const NETWORK_SUBTITLES: Record<SelectableNetwork, string> = {
+  mainnet: 'Best for high-value identities and highest security',
+  base:    'Best for lower-cost setup and routine updates',
+}
+
+export function networkSubtitle(network: SelectableNetwork): string {
+  return NETWORK_SUBTITLES[network]
+}
+
+export function chainSummaryRow(config?: EthagentConfig, identity?: EthagentIdentity): {
+  label: string
+  value: string
+  tone: 'ok' | 'dim'
+} {
+  const network = resolveSelectedNetwork(config)
+  const fromIdentity = identity?.chainId ? supportedErc8004ChainForId(identity.chainId)?.name.toLowerCase() : undefined
+  const value = fromIdentity ?? networkLabel(network)
+  return { label: 'chain', value, tone: identity?.chainId ? 'ok' : 'dim' }
+}

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

@@ -0,0 +1,57 @@
+import type { EthagentIdentity, TransferSnapshotMetadata } from '../../../storage/config.js'
+
+export type TransferSnapshotView =
+  | {
+      kind: 'ready-to-transfer'
+      sender: string
+      receiver: string
+      receiverHandle?: string
+      slotCount: number
+    }
+  | {
+      kind: 'received'
+      sender: string
+      receiver: string
+      receiverHandle?: string
+      slotCount: number
+    }
+  | null
+
+export function transferSnapshotView(identity?: EthagentIdentity | null): TransferSnapshotView {
+  const snapshot = identity?.backup?.transferSnapshot
+  if (!identity || !isDualWalletTransferSnapshot(snapshot)) return null
+  const owner = identity.ownerAddress ?? identity.address
+  if (!owner) return null
+  const ownerKey = owner.toLowerCase()
+  const senderKey = snapshot.senderAddress.toLowerCase()
+  const receiverKey = snapshot.receiverAddress.toLowerCase()
+  if (snapshot.slotCount < 2) return null
+  if (ownerKey === senderKey) {
+    return {
+      kind: 'ready-to-transfer',
+      sender: snapshot.senderAddress,
+      receiver: snapshot.receiverAddress,
+      ...(snapshot.receiverHandle ? { receiverHandle: snapshot.receiverHandle } : {}),
+      slotCount: snapshot.slotCount,
+    }
+  }
+  if (ownerKey === receiverKey) {
+    return {
+      kind: 'received',
+      sender: snapshot.senderAddress,
+      receiver: snapshot.receiverAddress,
+      ...(snapshot.receiverHandle ? { receiverHandle: snapshot.receiverHandle } : {}),
+      slotCount: snapshot.slotCount,
+    }
+  }
+  return null
+}
+
+function isDualWalletTransferSnapshot(value: unknown): value is TransferSnapshotMetadata {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const snapshot = value as Partial<TransferSnapshotMetadata>
+  return snapshot.kind === 'dual-wallet'
+    && typeof snapshot.senderAddress === 'string'
+    && typeof snapshot.receiverAddress === 'string'
+    && typeof snapshot.slotCount === 'number'
+}