@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/lib/server/tool-loop-detection.ts

@@ -0,0 +1,260 @@
+/**
+ * Tool loop detection — modelled after OpenClaw's approach.
+ *
+ * Four detectors run on every on_tool_end event:
+ * 1. Generic repeat    — same (name, inputHash) seen N+ times
+ * 2. Polling stall     — repeated poll-like calls with identical output
+ * 3. Ping-pong         — two tools alternating with identical results
+ * 4. Circuit breaker   — absolute cap on identical calls regardless of type
+ *
+ * Each detector returns a severity: 'ok' | 'warning' | 'critical'.
+ * The caller decides what to do (log, inject guidance, abort).
+ */
+
+import { createHash } from 'crypto'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ToolCallRecord {
+  name: string
+  inputHash: string
+  outputHash: string
+  /** first 200 chars of output for logging */
+  outputPreview: string
+  timestamp: number
+}
+
+export type LoopSeverity = 'ok' | 'warning' | 'critical'
+
+export interface LoopDetectionResult {
+  severity: LoopSeverity
+  detector: 'generic_repeat' | 'polling_stall' | 'ping_pong' | 'circuit_breaker' | 'tool_frequency'
+  message: string
+}
+
+export interface LoopDetectionThresholds {
+  /** Generic repeat: warn after this many identical (name, input) calls. Default 6. */
+  repeatWarn: number
+  /** Generic repeat: critical after this many. Default 12. */
+  repeatCritical: number
+  /** Polling stall: warn after N poll-like calls with identical output. Default 4. */
+  pollWarn: number
+  /** Polling stall: critical after this many. Default 8. */
+  pollCritical: number
+  /** Ping-pong: how many alternating-pair cycles trigger warning. Default 3. */
+  pingPongWarn: number
+  /** Ping-pong: critical after this many cycles. Default 5. */
+  pingPongCritical: number
+  /** Circuit breaker: absolute cap on any identical call. Default 20. */
+  circuitBreaker: number
+  /** Per-tool frequency: warn after this many calls to the same tool (any input). Default 5. */
+  toolFrequencyWarn: number
+  /** Per-tool frequency: critical after this many calls to the same tool (any input). Default 8. */
+  toolFrequencyCritical: number
+}
+
+const DEFAULT_THRESHOLDS: LoopDetectionThresholds = {
+  repeatWarn: 6,
+  repeatCritical: 12,
+  pollWarn: 4,
+  pollCritical: 8,
+  pingPongWarn: 3,
+  pingPongCritical: 5,
+  circuitBreaker: 20,
+  toolFrequencyWarn: 3,
+  toolFrequencyCritical: 5,
+}
+
+// ---------------------------------------------------------------------------
+// Hash helpers
+// ---------------------------------------------------------------------------
+
+function quickHash(input: string): string {
+  return createHash('sha256').update(input).digest('hex').slice(0, 16)
+}
+
+export function hashToolInput(input: unknown): string {
+  const str = typeof input === 'string' ? input : JSON.stringify(input ?? '')
+  return quickHash(str)
+}
+
+export function hashToolOutput(output: unknown): string {
+  const str = typeof output === 'string' ? output : JSON.stringify(output ?? '')
+  return quickHash(str)
+}
+
+// ---------------------------------------------------------------------------
+// Tracker
+// ---------------------------------------------------------------------------
+
+export class ToolLoopTracker {
+  private history: ToolCallRecord[] = []
+  private thresholds: LoopDetectionThresholds
+
+  constructor(thresholds?: Partial<LoopDetectionThresholds>) {
+    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds }
+  }
+
+  /** Record a completed tool call and run all detectors. */
+  record(name: string, input: unknown, output: unknown): LoopDetectionResult | null {
+    const inputHash = hashToolInput(input)
+    const outputStr = typeof output === 'string' ? output : JSON.stringify(output ?? '')
+    const outputHash = hashToolOutput(output)
+    const record: ToolCallRecord = {
+      name,
+      inputHash,
+      outputHash,
+      outputPreview: outputStr.slice(0, 200),
+      timestamp: Date.now(),
+    }
+    this.history.push(record)
+
+    // Run detectors in severity order (most severe first)
+    return this.checkCircuitBreaker(record)
+      ?? this.checkToolFrequency(record)
+      ?? this.checkGenericRepeat(record)
+      ?? this.checkPollingStall(record)
+      ?? this.checkPingPong()
+      ?? null
+  }
+
+  /** Get the full call history (for diagnostics). */
+  getHistory(): ReadonlyArray<ToolCallRecord> {
+    return this.history
+  }
+
+  /** Total recorded calls. */
+  get size(): number {
+    return this.history.length
+  }
+
+  // -------------------------------------------------------------------------
+  // Detectors
+  // -------------------------------------------------------------------------
+
+  private checkToolFrequency(current: ToolCallRecord): LoopDetectionResult | null {
+    let count = 0
+    for (const r of this.history) {
+      if (r.name === current.name) count++
+    }
+    if (count >= this.thresholds.toolFrequencyCritical) {
+      return {
+        severity: 'critical',
+        detector: 'tool_frequency',
+        message: `Tool "${current.name}" called ${count} times this turn. Excessive repetition — wrap up with available results.`,
+      }
+    }
+    if (count >= this.thresholds.toolFrequencyWarn) {
+      return {
+        severity: 'warning',
+        detector: 'tool_frequency',
+        message: `Tool "${current.name}" called ${count} times. Consider whether more calls are needed.`,
+      }
+    }
+    return null
+  }
+
+  private checkCircuitBreaker(current: ToolCallRecord): LoopDetectionResult | null {
+    const key = `${current.name}:${current.inputHash}`
+    let count = 0
+    for (const r of this.history) {
+      if (`${r.name}:${r.inputHash}` === key) count++
+    }
+    if (count >= this.thresholds.circuitBreaker) {
+      return {
+        severity: 'critical',
+        detector: 'circuit_breaker',
+        message: `Circuit breaker: "${current.name}" called ${count} times with identical input. Halting to prevent runaway.`,
+      }
+    }
+    return null
+  }
+
+  private checkGenericRepeat(current: ToolCallRecord): LoopDetectionResult | null {
+    const key = `${current.name}:${current.inputHash}`
+    let count = 0
+    for (const r of this.history) {
+      if (`${r.name}:${r.inputHash}` === key) count++
+    }
+    if (count >= this.thresholds.repeatCritical) {
+      return {
+        severity: 'critical',
+        detector: 'generic_repeat',
+        message: `Tool "${current.name}" has been called ${count} times with the same input. This appears to be a stuck loop.`,
+      }
+    }
+    if (count >= this.thresholds.repeatWarn) {
+      return {
+        severity: 'warning',
+        detector: 'generic_repeat',
+        message: `Tool "${current.name}" has been called ${count} times with the same input. Consider a different approach.`,
+      }
+    }
+    return null
+  }
+
+  private checkPollingStall(current: ToolCallRecord): LoopDetectionResult | null {
+    // Look for recent sequential calls to the same tool with identical output
+    const recent = this.history.slice(-this.thresholds.pollCritical)
+    const pollRuns = recent.filter(
+      (r) => r.name === current.name && r.outputHash === current.outputHash,
+    )
+    if (pollRuns.length >= this.thresholds.pollCritical) {
+      return {
+        severity: 'critical',
+        detector: 'polling_stall',
+        message: `Polling stall: "${current.name}" returned identical output ${pollRuns.length} times consecutively. The polled resource is not changing.`,
+      }
+    }
+    if (pollRuns.length >= this.thresholds.pollWarn) {
+      return {
+        severity: 'warning',
+        detector: 'polling_stall',
+        message: `Polling stall: "${current.name}" returned identical output ${pollRuns.length} times. The state may not be progressing.`,
+      }
+    }
+    return null
+  }
+
+  private checkPingPong(): LoopDetectionResult | null {
+    const len = this.history.length
+    if (len < 4) return null
+
+    // Check if the last N calls form an A-B-A-B pattern with identical results
+    const last = this.history[len - 1]
+    const prev = this.history[len - 2]
+    if (last.name === prev.name) return null // same tool — not ping-pong
+
+    let cycles = 0
+    for (let i = len - 2; i >= 1; i -= 2) {
+      const a = this.history[i]
+      const b = this.history[i - 1]
+      if (
+        a.name === last.name && a.outputHash === last.outputHash
+        && b.name === prev.name && b.outputHash === prev.outputHash
+      ) {
+        cycles++
+      } else {
+        break
+      }
+    }
+
+    if (cycles >= this.thresholds.pingPongCritical) {
+      return {
+        severity: 'critical',
+        detector: 'ping_pong',
+        message: `Ping-pong: "${prev.name}" and "${last.name}" are alternating with identical results (${cycles} cycles). Breaking the loop.`,
+      }
+    }
+    if (cycles >= this.thresholds.pingPongWarn) {
+      return {
+        severity: 'warning',
+        detector: 'ping_pong',
+        message: `Ping-pong: "${prev.name}" and "${last.name}" may be stuck in an alternating loop (${cycles} cycles).`,
+      }
+    }
+    return null
+  }
+}

package/src/lib/server/tool-planning.ts

@@ -11,6 +11,8 @@ export const TOOL_CAPABILITY = {
   deliveryMessage: 'delivery.message',
   deliveryMedia: 'delivery.media',
   deliveryVoiceNote: 'delivery.voice_note',
+  walletInspect: 'wallet.inspect',
+  walletExecute: 'wallet.execute',
 } as const
 
 export interface ToolPlanningEntry {
@@ -59,7 +61,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
       requestMatchers: [
         {
           capability: TOOL_CAPABILITY.researchSearch,
-          patterns: ['research', 'look up', 'find out', 'search for', 'compare', 'latest', 'news', 'headline', 'current event', 'recent update', "what's new", 'what happened'],
+          patterns: ['research', 'look up', 'find out', 'search for', 'compare', 'latest', 'news', 'headline', 'current event', 'recent update', 'update', 'updates', 'breaking', 'developments', 'keep watching', 'watch for', 'watching for', 'monitor', 'track', "what's new", 'what happened'],
           forbidLiteralUrl: true,
         },
       ],
@@ -121,7 +123,7 @@ const CORE_TOOL_PLANNING: Record<string, ToolPlanningEntry[]> = {
         },
         {
           capability: TOOL_CAPABILITY.deliveryMedia,
-          patterns: ['screenshot', 'screen shot', 'snapshot', 'image', 'photo', 'file', 'pdf', 'attachment'],
+          patterns: ['screenshot', 'screen shot', 'snapshot', 'image', 'photo', 'send file', 'send a file', 'pdf', 'attachment'],
         },
         {
           capability: TOOL_CAPABILITY.deliveryVoiceNote,

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

@@ -0,0 +1,198 @@
+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('./storage').encryptKey
+let callEthereumContract: typeof import('./ethereum').callEthereumContract
+let encodeEthereumContractCall: typeof import('./ethereum').encodeEthereumContractCall
+let prepareEvmSwapPlan: typeof import('./evm-swap').prepareEvmSwapPlan
+let signEthereumMessage: typeof import('./ethereum').signEthereumMessage
+let signEthereumTypedData: typeof import('./ethereum').signEthereumTypedData
+let generateSolanaKeypair: typeof import('./solana').generateSolanaKeypair
+let signSolanaMessage: typeof import('./solana').signSolanaMessage
+let signSolanaTransaction: typeof import('./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('./storage'))
+  ;({ callEthereumContract, encodeEthereumContractCall, signEthereumMessage, signEthereumTypedData } = await import('./ethereum'))
+  ;({ prepareEvmSwapPlan } = await import('./evm-swap'))
+  ;({ generateSolanaKeypair, signSolanaMessage, signSolanaTransaction } = await import('./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-portfolio.test.ts

@@ -0,0 +1,98 @@
+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 './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')
+  })
+})