@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/app/api/wallets/[id]/route.ts

@@ -1,12 +1,46 @@
 import { NextResponse } from 'next/server'
 import { loadWallets, upsertWallet, deleteWallet as deleteWalletFromStore, loadAgents, saveAgents } from '@/lib/server/storage'
-import { getBalance, lamportsToSol } from '@/lib/server/solana'
 import { notify } from '@/lib/server/ws-hub'
-import type { AgentWallet } from '@/types'
+import { getWalletLimitAtomic, normalizeAtomicString } from '@/lib/wallet'
+import type { AgentWallet, WalletAssetBalance, WalletPortfolioSummary } from '@/types'
+import { buildEmptyWalletPortfolio } from '@/lib/server/wallet-portfolio'
+import {
+  getAgentActiveWalletId,
+  getWalletPortfolioSnapshot,
+  linkWalletToAgent,
+  setAgentActiveWallet,
+  stripWalletPrivateKey,
+  unlinkWalletFromAgent,
+} from '@/lib/server/wallet-service'
 export const dynamic = 'force-dynamic'
-
-function stripPrivateKey(wallet: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(Object.entries(wallet).filter(([k]) => k !== 'encryptedPrivateKey'))
+const WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS = 2500
+
+function withPortfolio(
+  wallet: AgentWallet,
+  portfolio: {
+    balanceAtomic: string
+    balanceFormatted: string
+    balanceSymbol: string
+    balanceDisplay: string
+    balanceLamports?: number
+    balanceSol?: number
+    assets: WalletAssetBalance[]
+    summary: WalletPortfolioSummary
+  },
+  isActive: boolean,
+) {
+  return {
+    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
+    balanceAtomic: portfolio.balanceAtomic,
+    balanceFormatted: portfolio.balanceFormatted,
+    balanceSymbol: portfolio.balanceSymbol,
+    balanceDisplay: portfolio.balanceDisplay,
+    balanceLamports: portfolio.balanceLamports,
+    balanceSol: portfolio.balanceSol,
+    assets: portfolio.assets,
+    portfolioSummary: portfolio.summary,
+    isActive,
+  }
 }
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -15,21 +49,19 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const wallet = wallets[id]
   if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
 
-  // Fetch live on-chain balance
-  let balanceLamports = 0
-  let balanceSol = 0
+  let portfolio = buildEmptyWalletPortfolio(wallet)
   try {
-    balanceLamports = await getBalance(wallet.publicKey)
-    balanceSol = lamportsToSol(balanceLamports)
+    portfolio = await getWalletPortfolioSnapshot(wallet, {
+      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
+      allowStale: true,
+    })
   } catch {
     // RPC failure — return 0
   }
 
-  return NextResponse.json({
-    ...stripPrivateKey(wallet as unknown as Record<string, unknown>),
-    balanceLamports,
-    balanceSol,
-  })
+  const agents = loadAgents()
+  const isActive = getAgentActiveWalletId(agents[wallet.agentId]) === wallet.id
+  return NextResponse.json(withPortfolio(wallet, portfolio, isActive))
 }
 
 export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -39,6 +71,7 @@ export async function PATCH(req: Request, { params }: { params: Promise<{ id: st
   if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
 
   const body = await req.json()
+  const shouldMakeActive = body.makeActive === true
 
   // Reassign wallet to a different agent
   if (typeof body.agentId === 'string' && body.agentId !== wallet.agentId) {
@@ -46,39 +79,51 @@ export async function PATCH(req: Request, { params }: { params: Promise<{ id: st
     const newAgent = agents[body.agentId]
     if (!newAgent) return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
 
-    // Check new agent doesn't already have a wallet
+    // Only one wallet per chain per agent.
     const allWallets = loadWallets() as Record<string, AgentWallet>
-    const conflict = Object.values(allWallets).find((w) => w.agentId === body.agentId && w.id !== id)
-    if (conflict) return NextResponse.json({ error: 'Target agent already has a wallet' }, { status: 409 })
+    const conflict = Object.values(allWallets).find((w) => w.agentId === body.agentId && w.id !== id && w.chain === wallet.chain)
+    if (conflict) return NextResponse.json({ error: `Target agent already has a ${wallet.chain} wallet` }, { status: 409 })
 
-    // Unlink old agent
     const oldAgent = agents[wallet.agentId]
     if (oldAgent) {
-      oldAgent.walletId = null
+      unlinkWalletFromAgent(oldAgent, id)
       oldAgent.updatedAt = Date.now()
       agents[wallet.agentId] = oldAgent
     }
 
-    // Link new agent
-    newAgent.walletId = id
+    linkWalletToAgent(newAgent, id, shouldMakeActive || getAgentActiveWalletId(newAgent) == null)
     newAgent.updatedAt = Date.now()
     agents[body.agentId] = newAgent
     saveAgents(agents)
     notify('agents')
 
     wallet.agentId = body.agentId
+  } else if (shouldMakeActive) {
+    const agents = loadAgents()
+    const agent = agents[wallet.agentId]
+    if (agent) {
+      setAgentActiveWallet(agent, id)
+      agent.updatedAt = Date.now()
+      agents[wallet.agentId] = agent
+      saveAgents(agents)
+      notify('agents')
+    }
   }
 
   if (body.label !== undefined) wallet.label = body.label
-  if (typeof body.spendingLimitLamports === 'number') wallet.spendingLimitLamports = body.spendingLimitLamports
-  if (typeof body.dailyLimitLamports === 'number') wallet.dailyLimitLamports = body.dailyLimitLamports
+  if (body.spendingLimitAtomic !== undefined || body.spendingLimitLamports !== undefined) {
+    wallet.spendingLimitAtomic = normalizeAtomicString(body.spendingLimitAtomic ?? body.spendingLimitLamports, getWalletLimitAtomic(wallet, 'perTx'))
+  }
+  if (body.dailyLimitAtomic !== undefined || body.dailyLimitLamports !== undefined) {
+    wallet.dailyLimitAtomic = normalizeAtomicString(body.dailyLimitAtomic ?? body.dailyLimitLamports, getWalletLimitAtomic(wallet, 'daily'))
+  }
   if (typeof body.requireApproval === 'boolean') wallet.requireApproval = body.requireApproval
   wallet.updatedAt = Date.now()
 
   upsertWallet(id, wallet)
   notify('wallets')
 
-  return NextResponse.json(stripPrivateKey(wallet as unknown as Record<string, unknown>))
+  return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -88,20 +133,19 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
 
   // Check if balance > 0 and warn
-  let balanceLamports = 0
+  let portfolio = buildEmptyWalletPortfolio(wallet)
   try {
-    balanceLamports = await getBalance(wallet.publicKey)
+    portfolio = await getWalletPortfolioSnapshot(wallet, {
+      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
+      allowStale: true,
+    })
   } catch { /* ignore */ }
 
-  if (balanceLamports > 0) {
-    // Still delete, but include warning
-  }
-
   // Unlink from agent
   const agents = loadAgents()
   const agent = agents[wallet.agentId]
   if (agent) {
-    agent.walletId = null
+    unlinkWalletFromAgent(agent, id)
     agent.updatedAt = Date.now()
     agents[wallet.agentId] = agent
     saveAgents(agents)
@@ -113,6 +157,8 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
 
   return NextResponse.json({
     ok: true,
-    warning: balanceLamports > 0 ? `Wallet had ${lamportsToSol(balanceLamports)} SOL remaining` : undefined,
+    warning: portfolio.summary.nonZeroAssets > 0
+      ? `Wallet still had ${portfolio.summary.nonZeroAssets} asset${portfolio.summary.nonZeroAssets === 1 ? '' : 's'} remaining, including ${portfolio.balanceDisplay}`
+      : undefined,
   })
 }

package/src/app/api/wallets/[id]/send/route.ts

@@ -1,9 +1,12 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
-import { loadWallets, loadWalletTransactions, upsertWalletTransaction } from '@/lib/server/storage'
-import { sendSol, isValidSolanaAddress, lamportsToSol } from '@/lib/server/solana'
+import { loadWallets, upsertWalletTransaction } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import type { AgentWallet, WalletTransaction } from '@/types'
+import {
+  normalizeAtomicString,
+} from '@/lib/wallet'
+import { isValidWalletAddress, sendWalletNativeAsset, validateWalletSendLimits } from '@/lib/server/wallet-service'
 export const dynamic = 'force-dynamic'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -14,36 +17,15 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   const body = await req.json()
   const toAddress = typeof body.toAddress === 'string' ? body.toAddress.trim() : ''
-  const amountLamports = typeof body.amountLamports === 'number' ? Math.floor(body.amountLamports) : 0
+  const amountAtomic = normalizeAtomicString(body.amountAtomic ?? body.amountLamports, '0')
   const memo = typeof body.memo === 'string' ? body.memo.slice(0, 500) : undefined
 
-  if (!toAddress || !isValidSolanaAddress(toAddress)) {
+  if (!toAddress || !isValidWalletAddress(wallet.chain, toAddress)) {
     return NextResponse.json({ error: 'Invalid recipient address' }, { status: 400 })
   }
-  if (amountLamports <= 0) {
-    return NextResponse.json({ error: 'Amount must be positive' }, { status: 400 })
-  }
-
-  // Per-tx spending limit
-  const perTxLimit = wallet.spendingLimitLamports ?? 100_000_000
-  if (amountLamports > perTxLimit) {
-    return NextResponse.json({
-      error: `Amount ${lamportsToSol(amountLamports)} SOL exceeds per-transaction limit of ${lamportsToSol(perTxLimit)} SOL`,
-    }, { status: 403 })
-  }
-
-  // 24h rolling daily limit
-  const dailyLimit = wallet.dailyLimitLamports ?? 1_000_000_000
-  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000
-  const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
-  const recentSends = Object.values(allTxs).filter(
-    (tx) => tx.walletId === id && tx.type === 'send' && tx.status === 'confirmed' && tx.timestamp > oneDayAgo,
-  )
-  const dailySpent = recentSends.reduce((sum, tx) => sum + tx.amountLamports, 0)
-  if (dailySpent + amountLamports > dailyLimit) {
-    return NextResponse.json({
-      error: `Daily limit exceeded. Spent ${lamportsToSol(dailySpent)} SOL in last 24h, limit is ${lamportsToSol(dailyLimit)} SOL`,
-    }, { status: 403 })
+  const limitError = validateWalletSendLimits({ wallet, amountAtomic })
+  if (limitError) {
+    return NextResponse.json({ error: limitError }, { status: limitError === 'Amount must be positive' ? 400 : 403 })
   }
 
   const txId = genId(8)
@@ -60,7 +42,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       signature: '',
       fromAddress: wallet.publicKey,
       toAddress,
-      amountLamports,
+      amountAtomic,
+      amountLamports: wallet.chain === 'solana' ? Number.parseInt(amountAtomic, 10) : undefined,
       status: 'pending_approval',
       memo,
       timestamp: now,
@@ -72,7 +55,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   // Auto-approved — sign and submit
   try {
-    const { signature, fee } = await sendSol(wallet.encryptedPrivateKey, toAddress, amountLamports)
+    const { signature, feeAtomic } = await sendWalletNativeAsset(wallet, toAddress, amountAtomic)
     const confirmedTx: WalletTransaction = {
       id: txId,
       walletId: id,
@@ -82,8 +65,10 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       signature,
       fromAddress: wallet.publicKey,
       toAddress,
-      amountLamports,
-      feeLamports: fee,
+      amountAtomic,
+      amountLamports: wallet.chain === 'solana' ? Number.parseInt(amountAtomic, 10) : undefined,
+      feeAtomic,
+      feeLamports: wallet.chain === 'solana' && feeAtomic ? Number.parseInt(feeAtomic, 10) : undefined,
       status: 'confirmed',
       memo,
       approvedBy: 'auto',
@@ -102,7 +87,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       signature: '',
       fromAddress: wallet.publicKey,
       toAddress,
-      amountLamports,
+      amountAtomic,
+      amountLamports: wallet.chain === 'solana' ? Number.parseInt(amountAtomic, 10) : undefined,
       status: 'failed',
       memo,
       timestamp: now,

package/src/app/api/wallets/route.ts

@@ -1,74 +1,91 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import { loadWallets, upsertWallet, loadAgents, saveAgents } from '@/lib/server/storage'
-import { generateSolanaKeypair } from '@/lib/server/solana'
-import { notify } from '@/lib/server/ws-hub'
-import type { AgentWallet, WalletChain } from '@/types'
+import { loadAgents, loadWallets } from '@/lib/server/storage'
+import { createAgentWallet, getAgentActiveWalletId, getWalletPortfolioSnapshot, stripWalletPrivateKey } from '@/lib/server/wallet-service'
+import { buildEmptyWalletPortfolio } from '@/lib/server/wallet-portfolio'
+import type { AgentWallet, WalletPortfolioSummary } from '@/types'
 export const dynamic = 'force-dynamic'
+const WALLET_LIST_PORTFOLIO_TIMEOUT_MS = 1500
 
-/** Strip encryptedPrivateKey from wallet for safe API responses */
-function stripPrivateKey(wallet: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(Object.entries(wallet).filter(([k]) => k !== 'encryptedPrivateKey'))
+function withPortfolio(
+  wallet: AgentWallet,
+  portfolio: {
+    balanceAtomic: string
+    balanceFormatted: string
+    balanceSymbol: string
+    balanceDisplay: string
+    balanceLamports?: number
+    balanceSol?: number
+    assets: unknown[]
+    summary: WalletPortfolioSummary
+  },
+  isActive: boolean,
+) {
+  return {
+    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
+    balanceAtomic: portfolio.balanceAtomic,
+    balanceFormatted: portfolio.balanceFormatted,
+    balanceSymbol: portfolio.balanceSymbol,
+    balanceDisplay: portfolio.balanceDisplay,
+    balanceLamports: portfolio.balanceLamports,
+    balanceSol: portfolio.balanceSol,
+    assets: portfolio.assets,
+    portfolioSummary: portfolio.summary,
+    isActive,
+  }
 }
 
-export async function GET() {
+export async function GET(req: Request) {
   const wallets = loadWallets() as Record<string, AgentWallet>
-  const safe = Object.fromEntries(
-    Object.entries(wallets).map(([id, w]) => [id, stripPrivateKey(w as unknown as Record<string, unknown>)]),
+  const agents = loadAgents()
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')?.trim() || ''
+  const walletEntries = Object.entries(wallets)
+    .filter(([, wallet]) => !agentId || wallet.agentId === agentId)
+  const entries = await Promise.all(
+    walletEntries.map(async ([id, wallet]) => {
+      let portfolio = buildEmptyWalletPortfolio(wallet)
+      try {
+        portfolio = await getWalletPortfolioSnapshot(wallet, {
+          timeoutMs: WALLET_LIST_PORTFOLIO_TIMEOUT_MS,
+          allowStale: true,
+        })
+      } catch {
+        // Slow or failed RPC discovery — return empty/stale portfolio for list view
+      }
+      const activeWalletId = getAgentActiveWalletId(agents[wallet.agentId])
+      return [id, withPortfolio(wallet, portfolio, activeWalletId === wallet.id)] as const
+    }),
   )
-  return NextResponse.json(safe)
+  return NextResponse.json(Object.fromEntries(entries))
 }
 
 export async function POST(req: Request) {
   const body = await req.json()
-  const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : ''
-  if (!agentId) {
-    return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
-  }
-
-  const agents = loadAgents()
-  if (!agents[agentId]) {
-    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
-  }
-
-  // Check agent doesn't already have a wallet
-  const existing = loadWallets() as Record<string, AgentWallet>
-  const hasWallet = Object.values(existing).some((w) => w.agentId === agentId)
-  if (hasWallet) {
-    return NextResponse.json({ error: 'Agent already has a wallet' }, { status: 409 })
+  try {
+    const wallet = createAgentWallet({
+      agentId: body.agentId,
+      chain: body.chain,
+      provider: body.provider,
+      label: body.label,
+      requireApproval: body.requireApproval,
+      spendingLimitAtomic: body.spendingLimitAtomic ?? body.spendingLimitLamports,
+      dailyLimitAtomic: body.dailyLimitAtomic ?? body.dailyLimitLamports,
+    })
+    return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    if (message === 'agentId is required') {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    if (/^Unsupported wallet chain or provider: /.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    if (message === 'Agent not found') {
+      return NextResponse.json({ error: message }, { status: 404 })
+    }
+    if (/^Agent already has a (solana|ethereum) wallet$/.test(message)) {
+      return NextResponse.json({ error: message }, { status: 409 })
+    }
+    return NextResponse.json({ error: message }, { status: 500 })
   }
-
-  const chain: WalletChain = body.chain === 'solana' ? 'solana' : 'solana' // extensible later
-  const { publicKey, encryptedPrivateKey } = generateSolanaKeypair()
-
-  const id = genId()
-  const now = Date.now()
-
-  const wallet: AgentWallet = {
-    id,
-    agentId,
-    chain,
-    publicKey,
-    encryptedPrivateKey,
-    label: typeof body.label === 'string' ? body.label : undefined,
-    spendingLimitLamports: typeof body.spendingLimitLamports === 'number' ? body.spendingLimitLamports : 100_000_000,
-    dailyLimitLamports: typeof body.dailyLimitLamports === 'number' ? body.dailyLimitLamports : 1_000_000_000,
-    requireApproval: body.requireApproval !== false,
-    createdAt: now,
-    updatedAt: now,
-  }
-
-  upsertWallet(id, wallet)
-
-  // Link wallet to agent
-  const agent = agents[agentId]
-  agent.walletId = id
-  agent.updatedAt = now
-  agents[agentId] = agent
-  saveAgents(agents)
-
-  notify('wallets')
-  notify('agents')
-
-  return NextResponse.json(stripPrivateKey(wallet as unknown as Record<string, unknown>))
 }

package/src/app/api/webhooks/[id]/route.ts

@@ -13,6 +13,18 @@ import { triggerWebhookWatchJobs } from '@/lib/server/watch-jobs'
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ops: CollectionOps<any> = { load: loadWebhooks, save: saveWebhooks }
 
+type WebhookPostDeps = {
+  enqueueRun: typeof enqueueSessionRun
+  enqueueEvent: typeof enqueueSystemEvent
+  requestHeartbeat: typeof requestHeartbeatNow
+}
+
+const defaultWebhookPostDeps: WebhookPostDeps = {
+  enqueueRun: enqueueSessionRun,
+  enqueueEvent: enqueueSystemEvent,
+  requestHeartbeat: requestHeartbeatNow,
+}
+
 function normalizeEvents(value: unknown): string[] {
   if (!Array.isArray(value)) return []
   return value
@@ -58,8 +70,11 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   return NextResponse.json({ ok: true })
 }
 
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
+export async function handleWebhookPost(
+  req: Request,
+  id: string,
+  deps: WebhookPostDeps = defaultWebhookPostDeps,
+) {
   const webhooks = loadWebhooks()
   const webhook = webhooks[id]
   if (!webhook) return notFound('Webhook not found')
@@ -176,7 +191,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       agentId: agent.id,
       parentSessionId: null,
       tools: agent.tools || [],
-      heartbeatEnabled: agent.heartbeatEnabled ?? true,
+      heartbeatEnabled: agent.heartbeatEnabled ?? false,
       heartbeatIntervalSec: agent.heartbeatIntervalSec ?? null,
     }
     sessions[session.id as string] = session
@@ -200,7 +215,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   ].join('\n')
 
   try {
-    const run = enqueueSessionRun({
+    const run = deps.enqueueRun({
       sessionId: sid,
       message: prompt,
       source: 'webhook',
@@ -209,9 +224,16 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     })
 
     // Enqueue system event + heartbeat wake
-    enqueueSystemEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
+    deps.enqueueEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
     if (webhook.agentId) {
-      requestHeartbeatNow({ agentId: webhook.agentId, reason: 'webhook' })
+      deps.requestHeartbeat({
+        agentId: webhook.agentId,
+        eventId: `webhook:${id}:${incomingEvent}:${Date.now()}`,
+        reason: 'webhook',
+        source: `webhook:${id}`,
+        resumeMessage: `Webhook received: ${webhook.name || id} (${incomingEvent})`,
+        detail: payloadPreview || '(empty payload)',
+      })
     }
 
     appendWebhookLog(genId(8), {
@@ -262,3 +284,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     })
   }
 }
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  return handleWebhookPost(req, id)
+}