@swarmclawai/swarmclaw 1.2.8 → 1.2.9

package/src/lib/server/solana.ts

@@ -1,327 +0,0 @@
-import {
-  Connection,
-  Keypair,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-  Transaction,
-  VersionedTransaction,
-  sendAndConfirmTransaction,
-} from '@solana/web3.js'
-import bs58 from 'bs58'
-import nacl from 'tweetnacl'
-
-import { decryptKey, encryptKey } from './storage'
-
-export type SolanaCluster = 'mainnet-beta' | 'devnet' | 'testnet'
-
-export interface SolanaExecutionOptions {
-  cluster?: SolanaCluster | string | null
-  rpcUrl?: string | null
-}
-
-export interface SolanaMessageInput {
-  message?: string | null
-  messageHex?: string | null
-  messageBase64?: string | null
-}
-
-const DEFAULT_RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com'
-
-function getClusterRpcUrl(cluster: SolanaCluster): string {
-  if (cluster === 'devnet') return process.env.SOLANA_DEVNET_RPC_URL || 'https://api.devnet.solana.com'
-  if (cluster === 'testnet') return process.env.SOLANA_TESTNET_RPC_URL || 'https://api.testnet.solana.com'
-  return process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com'
-}
-
-function normalizeHexMessage(value: string): Uint8Array {
-  const trimmed = value.trim()
-  if (!/^0x[0-9a-fA-F]*$/.test(trimmed)) {
-    throw new Error('messageHex must be a 0x-prefixed hex string')
-  }
-  return Uint8Array.from(Buffer.from(trimmed.slice(2), 'hex'))
-}
-
-function normalizeMessageBytes(input: SolanaMessageInput): Uint8Array {
-  if (typeof input.messageHex === 'string' && input.messageHex.trim()) return normalizeHexMessage(input.messageHex)
-  if (typeof input.messageBase64 === 'string' && input.messageBase64.trim()) {
-    return Uint8Array.from(Buffer.from(input.messageBase64.trim(), 'base64'))
-  }
-  if (typeof input.message === 'string') return new TextEncoder().encode(input.message)
-  throw new Error('message, messageHex, or messageBase64 is required')
-}
-
-function deserializeTransactionBase64(value: string): Transaction | VersionedTransaction {
-  const bytes = Buffer.from(value, 'base64')
-  try {
-    return VersionedTransaction.deserialize(bytes)
-  } catch {
-    return Transaction.from(bytes)
-  }
-}
-
-function serializeTransactionBase64(transaction: Transaction | VersionedTransaction): string {
-  return Buffer.from(transaction.serialize()).toString('base64')
-}
-
-function collectTransactionSignatures(transaction: Transaction | VersionedTransaction): string[] {
-  if (transaction instanceof VersionedTransaction) {
-    return transaction.signatures
-      .map((signature) => bs58.encode(signature))
-      .filter(Boolean)
-  }
-  return transaction.signatures
-    .map((entry) => (entry.signature ? bs58.encode(entry.signature) : ''))
-    .filter(Boolean)
-}
-
-function signTransactionWithWallet(
-  encryptedPrivateKey: string,
-  transaction: Transaction | VersionedTransaction,
-): { transaction: Transaction | VersionedTransaction; publicKey: string } {
-  const keypair = getKeypairFromEncrypted(encryptedPrivateKey)
-  if (transaction instanceof VersionedTransaction) {
-    transaction.sign([keypair])
-  } else {
-    transaction.sign(keypair)
-  }
-  return {
-    transaction,
-    publicKey: keypair.publicKey.toBase58(),
-  }
-}
-
-export function generateSolanaKeypair(): { publicKey: string; encryptedPrivateKey: string } {
-  const keypair = Keypair.generate()
-  const secretKeyBase58 = bs58.encode(keypair.secretKey)
-  return {
-    publicKey: keypair.publicKey.toBase58(),
-    encryptedPrivateKey: encryptKey(secretKeyBase58),
-  }
-}
-
-export function getKeypairFromEncrypted(encryptedPrivateKey: string): Keypair {
-  const secretKeyBase58 = decryptKey(encryptedPrivateKey)
-  const secretKey = bs58.decode(secretKeyBase58)
-  return Keypair.fromSecretKey(secretKey)
-}
-
-export function normalizeSolanaCluster(value: unknown, fallback: SolanaCluster = 'mainnet-beta'): SolanaCluster {
-  const normalized = String(value ?? '').trim().toLowerCase()
-  if (!normalized) return fallback
-  if (normalized === 'mainnet' || normalized === 'mainnet-beta' || normalized === 'solana') return 'mainnet-beta'
-  if (normalized === 'devnet') return 'devnet'
-  if (normalized === 'testnet') return 'testnet'
-  throw new Error(`Unsupported Solana cluster: ${String(value)}`)
-}
-
-export function getSolanaClusterLabel(value?: unknown): string {
-  const cluster = normalizeSolanaCluster(value)
-  if (cluster === 'devnet') return 'Solana Devnet'
-  if (cluster === 'testnet') return 'Solana Testnet'
-  return 'Solana Mainnet'
-}
-
-export function getSolanaExplorerUrl(cluster: SolanaCluster | string | null | undefined, kind: 'address' | 'transaction', value: string): string {
-  const normalized = normalizeSolanaCluster(cluster)
-  const prefix = kind === 'address' ? 'address' : 'tx'
-  const clusterSuffix = normalized === 'mainnet-beta' ? '' : `?cluster=${normalized}`
-  return `https://explorer.solana.com/${prefix}/${value}${clusterSuffix}`
-}
-
-const CONNECTION_CACHE_MAX = 50
-const connectionCache = new Map<string, Connection>()
-
-function getCachedConnection(url: string): Connection {
-  let conn = connectionCache.get(url)
-  if (!conn) {
-    // FIFO eviction if cache exceeds cap
-    if (connectionCache.size >= CONNECTION_CACHE_MAX) {
-      const firstKey = connectionCache.keys().next().value
-      if (firstKey !== undefined) connectionCache.delete(firstKey)
-    }
-    conn = new Connection(url, {
-      commitment: 'confirmed',
-      disableRetryOnRateLimit: true,
-    })
-    connectionCache.set(url, conn)
-  }
-  return conn
-}
-
-export function getConnection(rpcUrl?: string): Connection {
-  return getCachedConnection(rpcUrl || DEFAULT_RPC_URL)
-}
-
-export function getConnectionForCluster(cluster?: SolanaCluster | string | null, rpcUrl?: string | null): Connection {
-  return getCachedConnection(rpcUrl || getClusterRpcUrl(normalizeSolanaCluster(cluster)))
-}
-
-export async function getBalance(publicKey: string, rpcUrl?: string): Promise<number> {
-  const connection = getConnection(rpcUrl)
-  const pk = new PublicKey(publicKey)
-  return connection.getBalance(pk)
-}
-
-export async function sendSol(
-  encryptedPrivateKey: string,
-  toAddress: string,
-  lamports: number,
-  rpcUrl?: string,
-): Promise<{ signature: string; fee: number }> {
-  const connection = getConnection(rpcUrl)
-  const fromKeypair = getKeypairFromEncrypted(encryptedPrivateKey)
-  const toPublicKey = new PublicKey(toAddress)
-
-  const transaction = new Transaction().add(
-    SystemProgram.transfer({
-      fromPubkey: fromKeypair.publicKey,
-      toPubkey: toPublicKey,
-      lamports,
-    }),
-  )
-
-  const signature = await sendAndConfirmTransaction(connection, transaction, [fromKeypair])
-
-  let fee = 5000
-  try {
-    const txInfo = await connection.getTransaction(signature, { commitment: 'confirmed' })
-    if (txInfo?.meta?.fee) fee = txInfo.meta.fee
-  } catch {
-    // keep default
-  }
-
-  return { signature, fee }
-}
-
-export async function signSolanaMessage(
-  encryptedPrivateKey: string,
-  input: SolanaMessageInput,
-): Promise<{ signature: string; publicKey: string }> {
-  const keypair = getKeypairFromEncrypted(encryptedPrivateKey)
-  const signature = nacl.sign.detached(normalizeMessageBytes(input), keypair.secretKey)
-  return {
-    signature: bs58.encode(signature),
-    publicKey: keypair.publicKey.toBase58(),
-  }
-}
-
-export async function signSolanaTransaction(
-  encryptedPrivateKey: string,
-  transactionBase64: string,
-): Promise<{
-    signedTransactionBase64: string
-    signatures: string[]
-    publicKey: string
-    versioned: boolean
-  }> {
-  const unsignedTx = deserializeTransactionBase64(transactionBase64)
-  const { transaction, publicKey } = signTransactionWithWallet(encryptedPrivateKey, unsignedTx)
-  return {
-    signedTransactionBase64: serializeTransactionBase64(transaction),
-    signatures: collectTransactionSignatures(transaction),
-    publicKey,
-    versioned: transaction instanceof VersionedTransaction,
-  }
-}
-
-export async function simulateSolanaTransaction(
-  encryptedPrivateKey: string,
-  transactionBase64: string,
-  options?: SolanaExecutionOptions,
-): Promise<{
-    signatures: string[]
-    publicKey: string
-    logs: string[]
-    unitsConsumed?: number
-    err?: unknown
-    versioned: boolean
-  }> {
-  const unsignedTx = deserializeTransactionBase64(transactionBase64)
-  const { transaction, publicKey } = signTransactionWithWallet(encryptedPrivateKey, unsignedTx)
-  const connection = getConnectionForCluster(options?.cluster, options?.rpcUrl)
-  const simulation = transaction instanceof VersionedTransaction
-    ? await connection.simulateTransaction(transaction)
-    : await connection.simulateTransaction(transaction)
-  return {
-    signatures: collectTransactionSignatures(transaction),
-    publicKey,
-    logs: simulation.value.logs || [],
-    unitsConsumed: simulation.value.unitsConsumed ?? undefined,
-    err: simulation.value.err ?? undefined,
-    versioned: transaction instanceof VersionedTransaction,
-  }
-}
-
-export async function sendSolanaTransaction(
-  encryptedPrivateKey: string,
-  input: {
-    transactionBase64?: string | null
-    signedTransactionBase64?: string | null
-    waitForConfirmation?: boolean
-  },
-  options?: SolanaExecutionOptions,
-): Promise<{
-    signature: string
-    publicKey: string
-    explorerUrl: string
-    versioned: boolean
-  }> {
-  const connection = getConnectionForCluster(options?.cluster, options?.rpcUrl)
-  const keypair = getKeypairFromEncrypted(encryptedPrivateKey)
-  const waitForConfirmation = input.waitForConfirmation !== false
-
-  let transaction: Transaction | VersionedTransaction
-  if (typeof input.signedTransactionBase64 === 'string' && input.signedTransactionBase64.trim()) {
-    transaction = deserializeTransactionBase64(input.signedTransactionBase64.trim())
-  } else if (typeof input.transactionBase64 === 'string' && input.transactionBase64.trim()) {
-    transaction = signTransactionWithWallet(encryptedPrivateKey, deserializeTransactionBase64(input.transactionBase64.trim())).transaction
-  } else {
-    throw new Error('transactionBase64 or signedTransactionBase64 is required')
-  }
-
-  const raw = transaction.serialize()
-  const signature = await connection.sendRawTransaction(raw)
-  if (waitForConfirmation) {
-    await connection.confirmTransaction(signature, 'confirmed')
-  }
-
-  return {
-    signature,
-    publicKey: keypair.publicKey.toBase58(),
-    explorerUrl: getSolanaExplorerUrl(options?.cluster, 'transaction', signature),
-    versioned: transaction instanceof VersionedTransaction,
-  }
-}
-
-export async function getRecentTransactions(
-  publicKey: string,
-  limit = 20,
-  rpcUrl?: string,
-): Promise<Array<{ signature: string; blockTime: number | null; err: unknown }>> {
-  const connection = getConnection(rpcUrl)
-  const pk = new PublicKey(publicKey)
-  const signatures = await connection.getSignaturesForAddress(pk, { limit })
-  return signatures.map((s) => ({
-    signature: s.signature,
-    blockTime: s.blockTime ?? null,
-    err: s.err,
-  }))
-}
-
-export function isValidSolanaAddress(address: string): boolean {
-  try {
-    new PublicKey(address)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function lamportsToSol(lamports: number): number {
-  return lamports / LAMPORTS_PER_SOL
-}
-
-export function solToLamports(sol: number): number {
-  return Math.round(sol * LAMPORTS_PER_SOL)
-}

package/src/lib/server/wallet/wallet-execution.test.ts

@@ -1,198 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { after, before, describe, it } from 'node:test'
-
-import type { AgentWallet } from '@/types'
-
-const originalEnv = {
-  DATA_DIR: process.env.DATA_DIR,
-  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
-  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
-  CREDENTIAL_SECRET: process.env.CREDENTIAL_SECRET,
-}
-
-let tempDir = ''
-let encryptKey: typeof import('@/lib/server/storage').encryptKey
-let callEthereumContract: typeof import('@/lib/server/ethereum').callEthereumContract
-let encodeEthereumContractCall: typeof import('@/lib/server/ethereum').encodeEthereumContractCall
-let prepareEvmSwapPlan: typeof import('@/lib/server/evm-swap').prepareEvmSwapPlan
-let signEthereumMessage: typeof import('@/lib/server/ethereum').signEthereumMessage
-let signEthereumTypedData: typeof import('@/lib/server/ethereum').signEthereumTypedData
-let generateSolanaKeypair: typeof import('@/lib/server/solana').generateSolanaKeypair
-let signSolanaMessage: typeof import('@/lib/server/solana').signSolanaMessage
-let signSolanaTransaction: typeof import('@/lib/server/solana').signSolanaTransaction
-let TransactionCtor: typeof import('@solana/web3.js').Transaction
-let SystemProgramNs: typeof import('@solana/web3.js').SystemProgram
-let PublicKeyCtor: typeof import('@solana/web3.js').PublicKey
-
-before(async () => {
-  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-wallet-exec-'))
-  process.env.DATA_DIR = path.join(tempDir, 'data')
-  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
-  process.env.SWARMCLAW_BUILD_MODE = '1'
-  process.env.CREDENTIAL_SECRET = '11'.repeat(32)
-  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
-  fs.mkdirSync(process.env.WORKSPACE_DIR, { recursive: true })
-
-  ;({ encryptKey } = await import('@/lib/server/storage'))
-  ;({ callEthereumContract, encodeEthereumContractCall, signEthereumMessage, signEthereumTypedData } = await import('@/lib/server/ethereum'))
-  ;({ prepareEvmSwapPlan } = await import('@/lib/server/evm-swap'))
-  ;({ generateSolanaKeypair, signSolanaMessage, signSolanaTransaction } = await import('@/lib/server/solana'))
-  ;({ Transaction: TransactionCtor, SystemProgram: SystemProgramNs, PublicKey: PublicKeyCtor } = await import('@solana/web3.js'))
-})
-
-after(() => {
-  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
-  else process.env.DATA_DIR = originalEnv.DATA_DIR
-  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
-  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
-  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
-  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
-  if (originalEnv.CREDENTIAL_SECRET === undefined) delete process.env.CREDENTIAL_SECRET
-  else process.env.CREDENTIAL_SECRET = originalEnv.CREDENTIAL_SECRET
-  fs.rmSync(tempDir, { recursive: true, force: true })
-})
-
-describe('wallet execution helpers', () => {
-  it('encodes ERC-20 contract calldata and signs EVM payloads', async () => {
-    const privateKey = '0x59c6995e998f97a5a004497e5d4ab3d89165b0def05d6d33923995df83329538'
-    const encrypted = encryptKey(privateKey)
-
-    const encoded = encodeEthereumContractCall(
-      ['function approve(address spender,uint256 amount)'],
-      'approve',
-      ['0x000000000000000000000000000000000000dEaD', '1000'],
-    )
-    assert.equal(encoded.data.startsWith('0x095ea7b3'), true)
-
-    const encodedFromNamedArgs = encodeEthereumContractCall(
-      ['function approve(address spender,uint256 amount)'],
-      'approve',
-      { spender: '0x000000000000000000000000000000000000dEaD', amount: '1000' },
-    )
-    assert.equal(encodedFromNamedArgs.data, encoded.data)
-
-    const encodedTupleArg = encodeEthereumContractCall(
-      ['function quoteExactInputSingle((address tokenIn,address tokenOut,uint256 amountIn,uint24 fee,uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut)'],
-      'quoteExactInputSingle',
-      {
-        tokenIn: '0x0000000000000000000000000000000000000001',
-        tokenOut: '0x0000000000000000000000000000000000000002',
-        amountIn: '1000000',
-        fee: 500,
-        sqrtPriceLimitX96: '0',
-      },
-    )
-    assert.equal(encodedTupleArg.data.startsWith('0xc6a5026a'), true)
-
-    const signedMessage = await signEthereumMessage(encrypted, { message: 'hello world' })
-    assert.equal(signedMessage.address.length, 42)
-    assert.equal(signedMessage.signature.startsWith('0x'), true)
-
-    const signedTypedData = await signEthereumTypedData(encrypted, {
-      domain: {
-        name: 'SwarmClaw',
-        version: '1',
-        chainId: 1,
-      },
-      types: {
-        Login: [
-          { name: 'wallet', type: 'address' },
-          { name: 'nonce', type: 'uint256' },
-        ],
-      },
-      value: {
-        wallet: signedMessage.address,
-        nonce: '7',
-      },
-    })
-    assert.equal(signedTypedData.signature.startsWith('0x'), true)
-
-    const called = await callEthereumContract(encrypted, {
-      contractAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-      abi: ['function name() view returns (string)'],
-      functionName: 'name',
-    }, {
-      network: 'ethereum',
-      rpcUrl: 'https://ethereum-rpc.publicnode.com',
-    })
-    assert.equal(called.decoded, 'Wrapped Ether')
-
-    const allowance = await callEthereumContract(encrypted, {
-      contractAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-      abi: ['function allowance(address owner,address spender) view returns (uint256)'],
-      functionName: 'allowance',
-      args: {
-        owner: signedMessage.address,
-        spender: '0x000000000000000000000000000000000000dEaD',
-      },
-    }, {
-      network: 'ethereum',
-      rpcUrl: 'https://ethereum-rpc.publicnode.com',
-    })
-    assert.equal(typeof allowance.decoded, 'string')
-  })
-
-  it('builds a generic ParaSwap-backed swap plan for Arbitrum without a venue-specific adapter', async () => {
-    const privateKey = '0x59c6995e998f97a5a004497e5d4ab3d89165b0def05d6d33923995df83329538'
-    const encrypted = encryptKey(privateKey)
-    const walletAddress = (await signEthereumMessage(encrypted, { message: 'derive address' })).address
-    const wallet: AgentWallet = {
-      id: 'wallet_swap_plan',
-      agentId: 'agent_wallet',
-      chain: 'ethereum',
-      publicKey: walletAddress,
-      encryptedPrivateKey: encrypted,
-      spendingLimitAtomic: '1000000000000000000',
-      dailyLimitAtomic: '10000000000000000000',
-      requireApproval: true,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    }
-
-    const plan = await prepareEvmSwapPlan({
-      wallet,
-      network: 'arbitrum',
-      sellToken: 'USDC',
-      buyToken: 'ETH',
-      sellAmountDisplay: '1',
-      skipBalanceCheck: true,
-    })
-
-    assert.equal(plan.provider, 'paraswap')
-    assert.equal(plan.network.id, 'arbitrum')
-    assert.equal(plan.sellToken.symbol, 'USDC')
-    assert.equal(plan.buyToken.symbol, 'ETH')
-    assert.equal(plan.sellAmountAtomic, '1000000')
-    assert.equal(plan.approvalRequired, true)
-    assert.equal(typeof plan.spenderAddress, 'string')
-    assert.equal(typeof plan.swapTransaction.to, 'string')
-    assert.equal(String(plan.swapTransaction.data || '').startsWith('0x'), true)
-  })
-
-  it('signs Solana messages and legacy transactions offline', async () => {
-    const sender = generateSolanaKeypair()
-    const recipient = generateSolanaKeypair()
-
-    const signedMessage = await signSolanaMessage(sender.encryptedPrivateKey, { message: 'solana hello' })
-    assert.equal(signedMessage.publicKey, sender.publicKey)
-    assert.equal(signedMessage.signature.length > 40, true)
-
-    const tx = new TransactionCtor()
-    tx.feePayer = new PublicKeyCtor(sender.publicKey)
-    tx.recentBlockhash = generateSolanaKeypair().publicKey
-    tx.add(SystemProgramNs.transfer({
-      fromPubkey: new PublicKeyCtor(sender.publicKey),
-      toPubkey: new PublicKeyCtor(recipient.publicKey),
-      lamports: 1_234,
-    }))
-
-    const unsignedBase64 = Buffer.from(tx.serialize({ requireAllSignatures: false, verifySignatures: false })).toString('base64')
-    const signedTx = await signSolanaTransaction(sender.encryptedPrivateKey, unsignedBase64)
-    assert.equal(signedTx.publicKey, sender.publicKey)
-    assert.equal(signedTx.signatures.length > 0, true)
-    assert.equal(typeof signedTx.signedTransactionBase64, 'string')
-  })
-})

package/src/lib/server/wallet/wallet-portfolio.test.ts

@@ -1,98 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-import type { AgentWallet } from '@/types'
-
-import {
-  buildLogDiscoveryRanges,
-  estimateDiscoveryStartBlock,
-  getKnownEvmTokenContracts,
-  parseMetaplexMetadataFields,
-  buildEmptyWalletPortfolio,
-  resolveWalletPortfolioWithTimeout,
-} from '@/lib/server/wallet/wallet-portfolio'
-
-describe('wallet portfolio helpers', () => {
-  it('splits large log discovery requests into provider-safe chunks', () => {
-    assert.deepEqual(buildLogDiscoveryRanges(10, 10, 50_000), [{ fromBlock: 10, toBlock: 10 }])
-    assert.deepEqual(buildLogDiscoveryRanges(1, 120_000, 50_000), [
-      { fromBlock: 1, toBlock: 50_000 },
-      { fromBlock: 50_001, toBlock: 100_000 },
-      { fromBlock: 100_001, toBlock: 120_000 },
-    ])
-  })
-
-  it('always checks canonical USDC contracts on supported EVM networks', () => {
-    assert.equal(
-      getKnownEvmTokenContracts('arbitrum').map((address) => address.toLowerCase()).includes('0xaf88d065e77c8cc2239327c5edb3a432268e5831'),
-      true,
-    )
-    assert.equal(
-      getKnownEvmTokenContracts('base').map((address) => address.toLowerCase()).includes('0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'),
-      true,
-    )
-    assert.equal(
-      getKnownEvmTokenContracts('ethereum').map((address) => address.toLowerCase()).includes('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
-      true,
-    )
-  })
-
-  it('scans from wallet age rather than capping discovery to a fixed recent window', () => {
-    const now = Date.UTC(2026, 2, 8)
-    const latestBlock = 10_000_000
-    const newerWalletStart = estimateDiscoveryStartBlock({
-      latestBlock,
-      walletCreatedAt: now - (7 * 24 * 60 * 60 * 1000),
-      avgBlockMs: 12_000,
-      maxDiscoveryBlocks: 5_000_000,
-      now,
-    })
-    const olderWalletStart = estimateDiscoveryStartBlock({
-      latestBlock,
-      walletCreatedAt: now - (30 * 24 * 60 * 60 * 1000),
-      avgBlockMs: 12_000,
-      maxDiscoveryBlocks: 5_000_000,
-      now,
-    })
-
-    assert.equal(olderWalletStart < newerWalletStart, true)
-  })
-
-  it('parses metaplex metadata name and symbol for arbitrary SPL mints', () => {
-    const data = Buffer.alloc(1 + 32 + 32 + 32 + 10)
-    Buffer.from('Example Token').copy(data, 1 + 32 + 32)
-    Buffer.from('EXMPL').copy(data, 1 + 32 + 32 + 32)
-
-    assert.deepEqual(parseMetaplexMetadataFields(data), {
-      name: 'Example Token',
-      symbol: 'EXMPL',
-    })
-  })
-
-  it('returns stale portfolio data when a live portfolio lookup times out', async () => {
-    const wallet: AgentWallet = {
-      id: 'wallet-timeout',
-      agentId: 'agent-timeout',
-      chain: 'ethereum',
-      publicKey: '0x0000000000000000000000000000000000000001',
-      encryptedPrivateKey: 'secret',
-      requireApproval: true,
-      spendingLimitAtomic: '1',
-      dailyLimitAtomic: '1',
-      createdAt: 1,
-      updatedAt: 1,
-    }
-    const stale = buildEmptyWalletPortfolio(wallet)
-    stale.balanceAtomic = '123'
-    stale.balanceFormatted = '0.000000000000000123'
-    stale.balanceDisplay = `${stale.balanceFormatted} ETH`
-
-    const result = await resolveWalletPortfolioWithTimeout({
-      load: () => new Promise<ReturnType<typeof buildEmptyWalletPortfolio>>(() => {}),
-      timeoutMs: 5,
-      stale,
-      label: 'wallet portfolio timeout test',
-    })
-
-    assert.equal(result.balanceAtomic, '123')
-  })
-})