@swarmclawai/swarmclaw 1.2.6 → 1.2.9

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

@@ -1,81 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import type { AgentWallet, WalletTransaction } from '@/types'
-
-import {
-  validateWalletSendLimits,
-  walletApprovalsGloballyEnabled,
-  walletRequiresApproval,
-} from '@/lib/server/wallet/wallet-service'
-
-function buildWallet(overrides: Partial<AgentWallet> = {}): AgentWallet {
-  return {
-    id: 'wallet-1',
-    agentId: 'agent-1',
-    chain: 'ethereum',
-    publicKey: '0x0000000000000000000000000000000000000001',
-    encryptedPrivateKey: 'secret',
-    requireApproval: true,
-    spendingLimitAtomic: '1000000000000000000',
-    dailyLimitAtomic: '1500000000000000000',
-    createdAt: 1,
-    updatedAt: 1,
-    ...overrides,
-  }
-}
-
-function buildTransaction(overrides: Partial<WalletTransaction> = {}): WalletTransaction {
-  return {
-    id: 'tx-1',
-    walletId: 'wallet-1',
-    agentId: 'agent-1',
-    chain: 'ethereum',
-    type: 'send',
-    signature: '0xhash',
-    fromAddress: '0xfrom',
-    toAddress: '0xto',
-    amountAtomic: '1000000000000000000',
-    status: 'confirmed',
-    timestamp: Date.now(),
-    ...overrides,
-  }
-}
-
-describe('validateWalletSendLimits', () => {
-  it('blocks approvals that would exceed the current daily limit', () => {
-    const wallet = buildWallet()
-    const transactions = [
-      buildTransaction({ id: 'existing', amountAtomic: '1000000000000000000' }),
-    ]
-
-    const error = validateWalletSendLimits({
-      wallet,
-      amountAtomic: '600000000000000000',
-      transactions,
-      now: Date.now(),
-    })
-
-    assert.match(error || '', /Daily limit exceeded/)
-  })
-})
-
-describe('wallet approval helpers', () => {
-  it('treats missing app setting as globally enabled', () => {
-    assert.equal(walletApprovalsGloballyEnabled(undefined), true)
-    assert.equal(walletApprovalsGloballyEnabled({}), true)
-  })
-
-  it('lets the global setting disable approval even for approval-required wallets', () => {
-    const wallet = buildWallet({ requireApproval: true })
-
-    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: true }), true)
-    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: false }), false)
-  })
-
-  it('still respects the per-wallet toggle when global approvals remain enabled', () => {
-    const wallet = buildWallet({ requireApproval: false })
-
-    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: true }), false)
-  })
-})

package/src/lib/server/wallet/wallet-service.ts

@@ -1,225 +0,0 @@
-import { genId } from '@/lib/id'
-import {
-  formatWalletAmount,
-  getWalletAssetSymbol,
-  getWalletAtomicAmount,
-  getWalletChainOrDefault,
-  getWalletDefaultLimitAtomic,
-  getWalletLimitAtomic,
-  normalizeAtomicString,
-} from '@/lib/wallet/wallet'
-import type { Agent, AgentWallet, WalletChain, WalletTransaction } from '@/types'
-import { dedup } from '@/lib/shared-utils'
-import { loadAgent, loadAgents, loadWalletTransactions, loadWallets, upsertAgent, upsertWallet } from '@/lib/server/storage'
-import { generateEthereumWallet, isValidEthereumAddress, sendEth } from '@/lib/server/ethereum'
-import { generateSolanaKeypair, isValidSolanaAddress, sendSol } from '@/lib/server/solana'
-import { notify } from '@/lib/server/ws-hub'
-import { clearWalletPortfolioCache, getWalletPortfolio, type GetWalletPortfolioOptions, type WalletPortfolio } from '@/lib/server/wallet/wallet-portfolio'
-
-function generateWalletCredentials(chain: WalletChain): { publicKey: string; encryptedPrivateKey: string } {
-  if (chain === 'ethereum') return generateEthereumWallet()
-  return generateSolanaKeypair()
-}
-
-export function stripWalletPrivateKey<T extends Record<string, unknown>>(wallet: T): Omit<T, 'encryptedPrivateKey'> {
-  return Object.fromEntries(Object.entries(wallet).filter(([key]) => key !== 'encryptedPrivateKey')) as Omit<T, 'encryptedPrivateKey'>
-}
-
-export function getAgentWalletIds(agent: Pick<Agent, 'walletIds' | 'walletId'> | null | undefined): string[] {
-  const ids = Array.isArray(agent?.walletIds)
-    ? agent.walletIds.filter((value): value is string => typeof value === 'string' && value.trim().length > 0)
-    : []
-  const legacy = typeof agent?.walletId === 'string' && agent.walletId.trim()
-    ? [agent.walletId.trim()]
-    : []
-  return dedup([...ids, ...legacy])
-}
-
-export function getAgentActiveWalletId(
-  agent: Pick<Agent, 'walletIds' | 'walletId' | 'activeWalletId'> | null | undefined,
-  walletIds = getAgentWalletIds(agent),
-): string | null {
-  if (typeof agent?.activeWalletId === 'string' && walletIds.includes(agent.activeWalletId)) return agent.activeWalletId
-  if (typeof agent?.walletId === 'string' && walletIds.includes(agent.walletId)) return agent.walletId
-  return walletIds[0] || null
-}
-
-function syncAgentWalletPointers(agent: Agent, walletIds: string[], activeWalletId?: string | null): Agent {
-  const normalizedIds = dedup(walletIds.filter(Boolean))
-  const normalizedActive = activeWalletId && normalizedIds.includes(activeWalletId)
-    ? activeWalletId
-    : normalizedIds[0] || null
-  agent.walletIds = normalizedIds
-  agent.activeWalletId = normalizedActive
-  agent.walletId = normalizedActive
-  return agent
-}
-
-export function linkWalletToAgent(agent: Agent, walletId: string, makeActive = false): Agent {
-  const walletIds = getAgentWalletIds(agent)
-  if (!walletIds.includes(walletId)) walletIds.push(walletId)
-  const activeWalletId = makeActive ? walletId : getAgentActiveWalletId(agent, walletIds)
-  return syncAgentWalletPointers(agent, walletIds, activeWalletId)
-}
-
-export function unlinkWalletFromAgent(agent: Agent, walletId: string): Agent {
-  const walletIds = getAgentWalletIds(agent).filter((id) => id !== walletId)
-  const activeWalletId = getAgentActiveWalletId(agent, walletIds)
-  return syncAgentWalletPointers(agent, walletIds, activeWalletId)
-}
-
-export function setAgentActiveWallet(agent: Agent, walletId: string | null): Agent {
-  const walletIds = getAgentWalletIds(agent)
-  const activeWalletId = walletId && walletIds.includes(walletId) ? walletId : walletIds[0] || null
-  return syncAgentWalletPointers(agent, walletIds, activeWalletId)
-}
-
-export function getWalletsByAgentId(agentId: string): AgentWallet[] {
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  return Object.values(wallets)
-    .filter((wallet) => wallet.agentId === agentId)
-    .sort((a, b) => a.createdAt - b.createdAt)
-}
-
-export function getWalletByAgentId(agentId: string, chain?: WalletChain | null): AgentWallet | null {
-  const wallets = getWalletsByAgentId(agentId)
-  if (chain) return wallets.find((wallet) => wallet.chain === chain) ?? null
-
-  const agents = loadAgents()
-  const agent = agents[agentId]
-  const activeWalletId = getAgentActiveWalletId(agent)
-  return wallets.find((wallet) => wallet.id === activeWalletId) ?? wallets[0] ?? null
-}
-
-export function walletApprovalsGloballyEnabled(
-  settings?: { walletApprovalsEnabled?: boolean | null } | null,
-): boolean {
-  return settings?.walletApprovalsEnabled !== false
-}
-
-export function walletRequiresApproval(
-  wallet: Pick<AgentWallet, 'requireApproval'>,
-  settings?: { walletApprovalsEnabled?: boolean | null } | null,
-): boolean {
-  return walletApprovalsGloballyEnabled(settings) && wallet.requireApproval !== false
-}
-
-export function createAgentWallet(input: {
-  agentId: string
-  chain?: WalletChain | string | null
-  provider?: WalletChain | string | null
-  label?: string
-  requireApproval?: boolean
-  spendingLimitAtomic?: string | number | null
-  dailyLimitAtomic?: string | number | null
-}): AgentWallet {
-  const agentId = String(input.agentId || '').trim()
-  if (!agentId) throw new Error('agentId is required')
-
-  const agent = loadAgent(agentId)
-  if (!agent) throw new Error('Agent not found')
-
-  const chain = getWalletChainOrDefault(input.chain ?? input.provider, 'solana')
-  const existing = getWalletByAgentId(agentId, chain)
-  if (existing) throw new Error(`Agent already has a ${chain} wallet`)
-  const { publicKey, encryptedPrivateKey } = generateWalletCredentials(chain)
-  const id = genId()
-  const now = Date.now()
-  const wallet: AgentWallet = {
-    id,
-    agentId,
-    chain,
-    publicKey,
-    encryptedPrivateKey,
-    label: typeof input.label === 'string' && input.label.trim() ? input.label.trim() : undefined,
-    spendingLimitAtomic: normalizeAtomicString(input.spendingLimitAtomic, getWalletDefaultLimitAtomic(chain, 'perTx')),
-    dailyLimitAtomic: normalizeAtomicString(input.dailyLimitAtomic, getWalletDefaultLimitAtomic(chain, 'daily')),
-    requireApproval: input.requireApproval !== false,
-    createdAt: now,
-    updatedAt: now,
-  }
-
-  upsertWallet(id, wallet)
-  clearWalletPortfolioCache(id)
-
-  linkWalletToAgent(agent as any, id, getAgentActiveWalletId(agent as any) == null)
-  agent.updatedAt = now
-  upsertAgent(agentId, agent)
-
-  notify('wallets')
-  notify('agents')
-
-  return wallet
-}
-
-export async function getWalletBalanceAtomic(wallet: AgentWallet): Promise<string> {
-  return (await getWalletPortfolio(wallet)).balanceAtomic
-}
-
-export async function getWalletPortfolioSnapshot(
-  wallet: AgentWallet,
-  options?: GetWalletPortfolioOptions,
-): Promise<WalletPortfolio> {
-  return getWalletPortfolio(wallet, options)
-}
-
-export function validateWalletSendLimits(params: {
-  wallet: AgentWallet
-  amountAtomic: string
-  transactions?: WalletTransaction[]
-  now?: number
-  excludeTransactionId?: string
-}): string | null {
-  const { wallet } = params
-  const amountAtomic = normalizeAtomicString(params.amountAtomic, '0')
-  const assetSymbol = getWalletAssetSymbol(wallet.chain)
-
-  if (BigInt(amountAtomic) <= BigInt(0)) {
-    return 'Amount must be positive'
-  }
-
-  const perTxLimitAtomic = getWalletLimitAtomic(wallet, 'perTx')
-  if (BigInt(amountAtomic) > BigInt(perTxLimitAtomic)) {
-    return `Amount ${formatWalletAmount(wallet.chain, amountAtomic, { maxFractionDigits: 6 })} ${assetSymbol} exceeds per-transaction limit of ${formatWalletAmount(wallet.chain, perTxLimitAtomic, { maxFractionDigits: 6 })} ${assetSymbol}`
-  }
-
-  const dailyLimitAtomic = getWalletLimitAtomic(wallet, 'daily')
-  const oneDayAgo = (params.now ?? Date.now()) - 24 * 60 * 60 * 1000
-  const transactions = params.transactions
-    ?? Object.values(loadWalletTransactions() as Record<string, WalletTransaction>)
-  const dailySpentAtomic = transactions
-    .filter((tx) => tx.walletId === wallet.id)
-    .filter((tx) => tx.id !== params.excludeTransactionId)
-    .filter((tx) => tx.type === 'send' && tx.status === 'confirmed' && tx.timestamp > oneDayAgo)
-    .reduce((sum, tx) => sum + BigInt(getWalletAtomicAmount(tx)), BigInt(0))
-
-  if (dailySpentAtomic + BigInt(amountAtomic) > BigInt(dailyLimitAtomic)) {
-    return `Daily limit exceeded. Spent ${formatWalletAmount(wallet.chain, dailySpentAtomic.toString(), { maxFractionDigits: 6 })} ${assetSymbol} in the last 24h, limit is ${formatWalletAmount(wallet.chain, dailyLimitAtomic, { maxFractionDigits: 6 })} ${assetSymbol}`
-  }
-
-  return null
-}
-
-export function isValidWalletAddress(chain: WalletChain, address: string): boolean {
-  if (chain === 'ethereum') return isValidEthereumAddress(address)
-  return isValidSolanaAddress(address)
-}
-
-export async function sendWalletNativeAsset(
-  wallet: AgentWallet,
-  toAddress: string,
-  amountAtomic: string,
-): Promise<{ signature: string; feeAtomic?: string }> {
-  if (wallet.chain === 'ethereum') {
-    const result = await sendEth(wallet.encryptedPrivateKey, toAddress, amountAtomic)
-    clearWalletPortfolioCache(wallet.id)
-    return { signature: result.signature, feeAtomic: result.fee }
-  }
-
-  const result = await sendSol(wallet.encryptedPrivateKey, toAddress, Number.parseInt(amountAtomic, 10))
-  clearWalletPortfolioCache(wallet.id)
-  return {
-    signature: result.signature,
-    feeAtomic: String(result.fee),
-  }
-}

package/src/lib/wallet/wallet-transactions.test.ts

@@ -1,75 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import type { WalletTransaction } from '@/types'
-
-import {
-  filterWalletTransactions,
-  getWalletTransactionStatusGroup,
-  matchesWalletTransactionFilter,
-  matchesWalletTransactionQuery,
-} from '@/lib/wallet/wallet-transactions'
-
-function buildTransaction(overrides: Partial<WalletTransaction> = {}): WalletTransaction {
-  return {
-    id: 'tx-1',
-    walletId: 'wallet-1',
-    agentId: 'agent-1',
-    chain: 'ethereum',
-    type: 'swap',
-    signature: '0xabc123',
-    fromAddress: '0xfrom000000000000000000000000000000000001',
-    toAddress: '0xto0000000000000000000000000000000000002',
-    amountAtomic: '1000000',
-    status: 'confirmed',
-    memo: 'Swapped 1 USDC to ETH',
-    timestamp: 1,
-    ...overrides,
-  }
-}
-
-describe('wallet transaction filters', () => {
-  it('groups pending and pending_approval together', () => {
-    assert.equal(getWalletTransactionStatusGroup('pending'), 'pending')
-    assert.equal(getWalletTransactionStatusGroup('pending_approval'), 'pending')
-    assert.equal(getWalletTransactionStatusGroup('confirmed'), 'confirmed')
-    assert.equal(getWalletTransactionStatusGroup('failed'), 'failed')
-    assert.equal(getWalletTransactionStatusGroup('denied'), 'failed')
-  })
-
-  it('matches filters by type and status group', () => {
-    assert.equal(matchesWalletTransactionFilter(buildTransaction({ type: 'swap' }), 'swap'), true)
-    assert.equal(matchesWalletTransactionFilter(buildTransaction({ type: 'send' }), 'send'), true)
-    assert.equal(matchesWalletTransactionFilter(buildTransaction({ status: 'pending_approval' }), 'pending'), true)
-    assert.equal(matchesWalletTransactionFilter(buildTransaction({ status: 'denied' }), 'failed'), true)
-  })
-
-  it('matches search queries against signature, memo, and addresses', () => {
-    const tx = buildTransaction()
-    assert.equal(matchesWalletTransactionQuery(tx, 'usdc'), true)
-    assert.equal(matchesWalletTransactionQuery(tx, '0xabc123'), true)
-    assert.equal(matchesWalletTransactionQuery(tx, '0xfrom0000'), true)
-    assert.equal(matchesWalletTransactionQuery(tx, 'missing-text'), false)
-  })
-
-  it('filters transactions by combined status/type and search query', () => {
-    const transactions = [
-      buildTransaction({ id: 'tx-confirmed', status: 'confirmed', memo: 'Swap USDC to ETH' }),
-      buildTransaction({ id: 'tx-pending', status: 'pending_approval', memo: 'Awaiting approval' }),
-      buildTransaction({ id: 'tx-send', type: 'send', status: 'confirmed', memo: 'Send ETH to treasury' }),
-    ]
-
-    assert.deepEqual(
-      filterWalletTransactions(transactions, { filter: 'pending' }).map((tx) => tx.id),
-      ['tx-pending'],
-    )
-    assert.deepEqual(
-      filterWalletTransactions(transactions, { filter: 'send', query: 'treasury' }).map((tx) => tx.id),
-      ['tx-send'],
-    )
-    assert.deepEqual(
-      filterWalletTransactions(transactions, { filter: 'confirmed', query: 'usdc' }).map((tx) => tx.id),
-      ['tx-confirmed'],
-    )
-  })
-})

package/src/lib/wallet/wallet-transactions.ts

@@ -1,43 +0,0 @@
-import type { WalletTransaction, WalletTransactionStatus } from '@/types'
-
-export type WalletTransactionFilter = 'all' | 'confirmed' | 'pending' | 'failed' | 'send' | 'receive' | 'swap'
-
-export function getWalletTransactionStatusGroup(status: WalletTransactionStatus): 'confirmed' | 'pending' | 'failed' {
-  if (status === 'confirmed') return 'confirmed'
-  if (status === 'pending' || status === 'pending_approval') return 'pending'
-  return 'failed'
-}
-
-export function matchesWalletTransactionFilter(tx: WalletTransaction, filter: WalletTransactionFilter): boolean {
-  if (filter === 'all') return true
-  if (filter === 'send' || filter === 'receive' || filter === 'swap') return tx.type === filter
-  return getWalletTransactionStatusGroup(tx.status) === filter
-}
-
-export function matchesWalletTransactionQuery(tx: WalletTransaction, query: string): boolean {
-  const normalized = query.trim().toLowerCase()
-  if (!normalized) return true
-  const haystack = [
-    tx.id,
-    tx.signature,
-    tx.memo || '',
-    tx.fromAddress,
-    tx.toAddress,
-    tx.status,
-    tx.type,
-    tx.tokenMint || '',
-    tx.approvedBy || '',
-  ]
-    .join(' ')
-    .toLowerCase()
-  return haystack.includes(normalized)
-}
-
-export function filterWalletTransactions(
-  transactions: WalletTransaction[],
-  options?: { filter?: WalletTransactionFilter; query?: string },
-): WalletTransaction[] {
-  const filter = options?.filter || 'all'
-  const query = options?.query || ''
-  return transactions.filter((tx) => matchesWalletTransactionFilter(tx, filter) && matchesWalletTransactionQuery(tx, query))
-}