nebula-ai-plugin-onchain 0.1.0

package/src/tokens.ts

@@ -0,0 +1,232 @@
+/**
+ * Token resolver + cache. Resolution priority:
+ *   cache → vendored AGNI list → on-chain ERC-20 reads (Multicall3 batch).
+ *
+ * The cache lives at <agentDir>/onchain/tokens-cache.json and is keyed by
+ * lowercase address. We cache-write whenever an on-chain read succeeds so
+ * subsequent runs skip the round-trip.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import {
+  type Address,
+  type PublicClient,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getAddress,
+} from 'viem'
+import agniTokenList from '../data/tokens.json' with { type: 'json' }
+import { ERC20_ABI, MULTICALL3_ABI } from './abis'
+import { MULTICALL3, NATIVE_ALIASES } from './constants'
+import type { TokenInfo } from './types'
+
+interface AgniTokenListEntry {
+  address: string
+  symbol: string
+  name: string
+  decimals: number
+  chainId: number
+}
+
+interface AgniTokenList {
+  tokens: AgniTokenListEntry[]
+}
+
+const TYPED_LIST = agniTokenList as AgniTokenList
+
+const NATIVE: TokenInfo = {
+  address: '0x0000000000000000000000000000000000000000' as Address,
+  symbol: 'Mantle',
+  name: 'Mantle',
+  decimals: 18,
+  source: 'native',
+}
+
+export function isNativeToken(input: string | undefined): boolean {
+  if (!input) return true
+  return NATIVE_ALIASES.has(input.trim())
+}
+
+export function nativeTokenInfo(): TokenInfo {
+  return { ...NATIVE }
+}
+
+function tokensCachePath(agentDir: string): string {
+  return join(agentDir, 'onchain', 'tokens-cache.json')
+}
+
+interface CacheFile {
+  version: 1
+  byAddress: Record<string, TokenInfo>
+}
+
+function emptyCache(): CacheFile {
+  return { version: 1, byAddress: {} }
+}
+
+export function loadTokenCache(agentDir: string): CacheFile {
+  const path = tokensCachePath(agentDir)
+  if (!existsSync(path)) return emptyCache()
+  try {
+    const raw = readFileSync(path, 'utf8')
+    const parsed = JSON.parse(raw) as CacheFile
+    if (parsed?.version === 1 && parsed.byAddress) return parsed
+    return emptyCache()
+  } catch {
+    return emptyCache()
+  }
+}
+
+export function saveTokenCache(agentDir: string, cache: CacheFile): void {
+  const path = tokensCachePath(agentDir)
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(cache, null, 2))
+}
+
+/**
+ * Best-effort lookup. Returns the token info if found in cache OR vendored
+ * list. On miss, callers should call `fetchOnchainErc20Info` to resolve via
+ * RPC and cache-write through.
+ */
+export function lookupFromList(symbolOrAddress: string, cache: CacheFile): TokenInfo | null {
+  const trimmed = symbolOrAddress.trim()
+  // Address path
+  if (trimmed.startsWith('0x') && trimmed.length === 42) {
+    const lc = trimmed.toLowerCase()
+    const cached = cache.byAddress[lc]
+    if (cached) return cached
+    const fromList = TYPED_LIST.tokens.find(t => t.address.toLowerCase() === lc)
+    if (fromList) return tokenFromListEntry(fromList)
+    return null
+  }
+  // Symbol path: case-insensitive match
+  const upper = trimmed.toUpperCase()
+  const fromCache = Object.values(cache.byAddress).find(t => t.symbol.toUpperCase() === upper)
+  if (fromCache) return fromCache
+  const fromList = TYPED_LIST.tokens.find(t => t.symbol.toUpperCase() === upper)
+  if (fromList) return tokenFromListEntry(fromList)
+  return null
+}
+
+function tokenFromListEntry(e: AgniTokenListEntry): TokenInfo {
+  return {
+    address: getAddress(e.address) as Address,
+    symbol: e.symbol,
+    name: e.name,
+    decimals: e.decimals,
+    source: 'list',
+  }
+}
+
+/**
+ * Read name/symbol/decimals for an ERC-20 via Multicall3 (single round-trip).
+ * Tolerates contracts that don't implement `name` (returns symbol as name);
+ * decimals + symbol are required. Returns null if the address isn't an ERC-20.
+ */
+export async function fetchOnchainErc20Info(
+  client: PublicClient,
+  address: Address,
+): Promise<TokenInfo | null> {
+  const calls = [
+    {
+      target: address,
+      allowFailure: true,
+      callData: encodeFunctionData({ abi: ERC20_ABI, functionName: 'name' }),
+    },
+    {
+      target: address,
+      allowFailure: true,
+      callData: encodeFunctionData({ abi: ERC20_ABI, functionName: 'symbol' }),
+    },
+    {
+      target: address,
+      allowFailure: true,
+      callData: encodeFunctionData({ abi: ERC20_ABI, functionName: 'decimals' }),
+    },
+  ] as const
+  let results: ReadonlyArray<{ success: boolean; returnData: `0x${string}` }>
+  try {
+    results = (await client.readContract({
+      address: MULTICALL3,
+      abi: MULTICALL3_ABI,
+      functionName: 'aggregate3',
+      args: [
+        calls as unknown as Array<{
+          target: Address
+          allowFailure: boolean
+          callData: `0x${string}`
+        }>,
+      ],
+    })) as ReadonlyArray<{ success: boolean; returnData: `0x${string}` }>
+  } catch {
+    return null
+  }
+  const decode = <T>(idx: number, fnName: 'name' | 'symbol' | 'decimals'): T | null => {
+    const r = results[idx]
+    if (!r?.success) return null
+    try {
+      return decodeFunctionResult({
+        abi: ERC20_ABI,
+        functionName: fnName,
+        data: r.returnData,
+      }) as T
+    } catch {
+      return null
+    }
+  }
+  const symbol = decode<string>(1, 'symbol')
+  const decimals = decode<number>(2, 'decimals')
+  if (symbol == null || decimals == null) return null
+  const name = decode<string>(0, 'name') ?? symbol
+  return {
+    address: getAddress(address) as Address,
+    symbol,
+    name,
+    decimals: Number(decimals),
+    source: 'onchain',
+  }
+}
+
+/** Resolve, with cache-write-through on on-chain hits. */
+export async function resolveToken(opts: {
+  client: PublicClient
+  agentDir: string
+  input: string
+}): Promise<TokenInfo | null> {
+  const { client, agentDir, input } = opts
+  if (isNativeToken(input)) return nativeTokenInfo()
+  const cache = loadTokenCache(agentDir)
+  const local = lookupFromList(input, cache)
+  if (local) return local
+  // Fall through to on-chain only for address inputs
+  if (input.startsWith('0x') && input.length === 42) {
+    const fetched = await fetchOnchainErc20Info(client, input as Address)
+    if (fetched) {
+      const updated: CacheFile = {
+        version: 1,
+        byAddress: { ...cache.byAddress, [fetched.address.toLowerCase()]: fetched },
+      }
+      saveTokenCache(agentDir, updated)
+      return fetched
+    }
+  }
+  return null
+}
+
+/** Persist a known-good token info (e.g. from balance discovery) to cache. */
+export function rememberToken(agentDir: string, token: TokenInfo): void {
+  const cache = loadTokenCache(agentDir)
+  cache.byAddress[token.address.toLowerCase()] = token
+  saveTokenCache(agentDir, cache)
+}
+
+/** Bulk variant for after a discovery scan. */
+export function rememberTokens(agentDir: string, tokens: TokenInfo[]): void {
+  if (tokens.length === 0) return
+  const cache = loadTokenCache(agentDir)
+  for (const t of tokens) {
+    cache.byAddress[t.address.toLowerCase()] = t
+  }
+  saveTokenCache(agentDir, cache)
+}

package/src/tools/aave.ts

@@ -0,0 +1,425 @@
+/**
+ * Aave V3 lending tools on Mantle: aave.position (read), aave.supply, aave.withdraw.
+ * Writes run the standard pipeline: policy -> approve (supply) -> simulate -> execute -> receipt.
+ */
+import type { ToolDef } from 'nebula-ai-core'
+import { getGasPriceWithFloor } from 'nebula-ai-core'
+import { type Abi, type Address, parseUnits } from 'viem'
+import { z } from 'zod'
+import {
+  AAVE_MAX_WITHDRAW,
+  AAVE_V3_POOL_ABI,
+  AAVE_VARIABLE_RATE,
+  formatBaseUsd,
+  formatHealthFactor,
+  readAaveAccount,
+  readAaveMarkets,
+} from '../aave'
+import { ensureAllowance } from '../allowance'
+import { AAVE_POOL_BY_NETWORK } from '../constants'
+import { evaluatePolicy } from '../policy'
+import { simulateContractWrite } from '../simulate'
+import { resolveToken } from '../tokens'
+import type { OnchainRuntimeContext } from '../types'
+import { waitForReceipt } from '../wait-receipt'
+
+function requirePool(ctx: OnchainRuntimeContext): Address {
+  const pool = AAVE_POOL_BY_NETWORK[ctx.network]
+  if (!pool) throw new Error(`Aave V3 is not deployed on ${ctx.network}`)
+  return pool
+}
+
+const PositionSchema = z.object({})
+type PositionArgs = z.infer<typeof PositionSchema>
+
+export function makeAavePosition(ctx: OnchainRuntimeContext): ToolDef<PositionArgs> {
+  return {
+    name: 'aave.position',
+    description:
+      'Read your Aave V3 position on Mantle: total collateral, debt, available borrows, and health factor.',
+    searchHint: 'aave lending position health factor collateral debt borrow liquidation',
+    schema: PositionSchema,
+    handler: async () => {
+      try {
+        const pool = requirePool(ctx)
+        const a = await readAaveAccount(ctx.publicClient, pool, ctx.agentEoa)
+        return {
+          ok: true,
+          data: {
+            totalCollateral: formatBaseUsd(a.totalCollateralBase),
+            totalDebt: formatBaseUsd(a.totalDebtBase),
+            availableBorrows: formatBaseUsd(a.availableBorrowsBase),
+            ltvBps: a.ltvBps.toString(),
+            liquidationThresholdBps: a.liquidationThresholdBps.toString(),
+            healthFactor: formatHealthFactor(a.healthFactorRaw),
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+const MarketsSchema = z.object({})
+type MarketsArgs = z.infer<typeof MarketsSchema>
+
+export function makeAaveMarkets(ctx: OnchainRuntimeContext): ToolDef<MarketsArgs> {
+  return {
+    name: 'aave.markets',
+    description:
+      'List every Aave V3 reserve on Mantle with its live supply APR and variable-borrow APR. Read-only. Use it to compare lending/borrowing rates before aave.supply or aave.borrow ("what does it cost to borrow USDC", "best supply rate").',
+    searchHint: 'aave markets reserves rates apr supply borrow interest lending cost which asset',
+    schema: MarketsSchema,
+    handler: async () => {
+      try {
+        const pool = requirePool(ctx)
+        const markets = await readAaveMarkets(ctx.publicClient, pool)
+        return {
+          ok: true,
+          data: {
+            count: markets.length,
+            markets: markets.map(m => ({
+              symbol: m.symbol,
+              address: m.address,
+              supplyApr: `${m.supplyAprPct.toFixed(2)}%`,
+              variableBorrowApr: `${m.variableBorrowAprPct.toFixed(2)}%`,
+            })),
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+const SupplySchema = z.object({
+  token: z.string().min(1).describe('ERC-20 symbol or 0x address to supply (e.g. WMNT, USDC).'),
+  amount: z.string().min(1).describe('Amount in token units (e.g. "10").'),
+})
+type SupplyArgs = z.infer<typeof SupplySchema>
+
+export function makeAaveSupply(ctx: OnchainRuntimeContext): ToolDef<SupplyArgs> {
+  return {
+    name: 'aave.supply',
+    description:
+      'Supply an ERC-20 to Aave V3 on Mantle (earns yield, becomes collateral). Auto-approves the Pool; policy-checked + simulated before execution.',
+    searchHint: 'aave supply deposit lend earn yield collateral',
+    schema: SupplySchema,
+    handler: async args => {
+      try {
+        const pool = requirePool(ctx)
+        const account = ctx.walletClient.account
+        if (!account) return { ok: false, error: 'walletClient has no account; cannot supply' }
+        const token = await resolveToken({
+          client: ctx.publicClient,
+          agentDir: ctx.agentDir,
+          input: args.token,
+        })
+        if (!token) return { ok: false, error: `unknown token: ${args.token}` }
+        const amount = parseUnits(args.amount, token.decimals)
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: token.address, amountRaw: amount },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        const allow = await ensureAllowance({
+          publicClient: ctx.publicClient,
+          walletClient: ctx.walletClient,
+          token: token.address,
+          owner: ctx.agentEoa,
+          spender: pool,
+          amount,
+        })
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: pool,
+          abi: AAVE_V3_POOL_ABI as Abi,
+          functionName: 'supply',
+          args: [token.address, amount, ctx.agentEoa, 0],
+        })
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation reverted: ${sim.reason}` }
+        const gasPrice = await getGasPriceWithFloor(ctx.publicClient)
+        const txHash = await ctx.walletClient.writeContract({
+          address: pool,
+          abi: AAVE_V3_POOL_ABI,
+          functionName: 'supply',
+          args: [token.address, amount, ctx.agentEoa, 0],
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            token: token.symbol,
+            amount: args.amount,
+            status: receipt.status === 'success' ? 'success' : 'reverted',
+            simGasEstimate: sim.gas.toString(),
+            policyEnforced: ctx.policy != null,
+            ...(allow.txHash ? { approveTxHash: allow.txHash } : {}),
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+/** Read the post-tx health factor so the receipt surfaces the risk impact. */
+async function healthFactorAfter(ctx: OnchainRuntimeContext, pool: Address): Promise<string> {
+  try {
+    const a = await readAaveAccount(ctx.publicClient, pool, ctx.agentEoa)
+    return formatHealthFactor(a.healthFactorRaw)
+  } catch {
+    return 'unknown'
+  }
+}
+
+const BorrowSchema = z.object({
+  token: z.string().min(1).describe('ERC-20 symbol or 0x address to borrow (e.g. USDC, USDT).'),
+  amount: z.string().min(1).describe('Amount to borrow in token units (e.g. "100").'),
+})
+type BorrowArgs = z.infer<typeof BorrowSchema>
+
+export function makeAaveBorrow(ctx: OnchainRuntimeContext): ToolDef<BorrowArgs> {
+  return {
+    name: 'aave.borrow',
+    description:
+      'Borrow an ERC-20 from Aave V3 on Mantle against your supplied collateral (variable rate). Policy-checked + simulated; Aave reverts a borrow beyond your borrowing power, so the pre-flight simulation catches an over-borrow before any tx. The receipt reports the resulting health factor — the lower it is, the closer to liquidation. Borrowing is leverage: keep it bounded.',
+    searchHint: 'aave borrow loan leverage debt against collateral variable rate credit',
+    schema: BorrowSchema,
+    handler: async args => {
+      try {
+        const pool = requirePool(ctx)
+        const account = ctx.walletClient.account
+        if (!account) return { ok: false, error: 'walletClient has no account; cannot borrow' }
+        const token = await resolveToken({
+          client: ctx.publicClient,
+          agentDir: ctx.agentDir,
+          input: args.token,
+        })
+        if (!token) return { ok: false, error: `unknown token: ${args.token}` }
+        const amount = parseUnits(args.amount, token.decimals)
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: token.address, amountRaw: amount },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        const borrowArgs = [token.address, amount, AAVE_VARIABLE_RATE, 0, ctx.agentEoa] as const
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: pool,
+          abi: AAVE_V3_POOL_ABI as Abi,
+          functionName: 'borrow',
+          args: borrowArgs,
+        })
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation reverted: ${sim.reason}` }
+        const gasPrice = await getGasPriceWithFloor(ctx.publicClient)
+        const txHash = await ctx.walletClient.writeContract({
+          address: pool,
+          abi: AAVE_V3_POOL_ABI,
+          functionName: 'borrow',
+          args: borrowArgs,
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            token: token.symbol,
+            amount: args.amount,
+            rateMode: 'variable',
+            status: receipt.status === 'success' ? 'success' : 'reverted',
+            healthFactorAfter: await healthFactorAfter(ctx, pool),
+            simGasEstimate: sim.gas.toString(),
+            policyEnforced: ctx.policy != null,
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+const RepaySchema = z.object({
+  token: z.string().min(1).describe('ERC-20 symbol or 0x address of the debt to repay.'),
+  amount: z.string().min(1).describe('Amount in token units, or "max" to repay the full debt.'),
+})
+type RepayArgs = z.infer<typeof RepaySchema>
+
+export function makeAaveRepay(ctx: OnchainRuntimeContext): ToolDef<RepayArgs> {
+  return {
+    name: 'aave.repay',
+    description:
+      'Repay an Aave V3 variable-rate debt on Mantle. Use "max" to clear the full debt. Auto-approves the Pool to pull the repayment; policy-checked + simulated. The receipt reports the improved health factor.',
+    searchHint: 'aave repay payback debt loan close deleverage',
+    schema: RepaySchema,
+    handler: async args => {
+      try {
+        const pool = requirePool(ctx)
+        const account = ctx.walletClient.account
+        if (!account) return { ok: false, error: 'walletClient has no account; cannot repay' }
+        const token = await resolveToken({
+          client: ctx.publicClient,
+          agentDir: ctx.agentDir,
+          input: args.token,
+        })
+        if (!token) return { ok: false, error: `unknown token: ${args.token}` }
+        const isMax = args.amount.toLowerCase() === 'max'
+        const amount = isMax ? AAVE_MAX_WITHDRAW : parseUnits(args.amount, token.decimals)
+        if (ctx.policy && !isMax) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: token.address, amountRaw: amount },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        // Approve enough to cover repayment. For "max" we can't know the exact
+        // debt cheaply, so approve the uint256 max (Aave pulls only what's owed).
+        const allow = await ensureAllowance({
+          publicClient: ctx.publicClient,
+          walletClient: ctx.walletClient,
+          token: token.address,
+          owner: ctx.agentEoa,
+          spender: pool,
+          amount,
+        })
+        const repayArgs = [token.address, amount, AAVE_VARIABLE_RATE, ctx.agentEoa] as const
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: pool,
+          abi: AAVE_V3_POOL_ABI as Abi,
+          functionName: 'repay',
+          args: repayArgs,
+        })
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation reverted: ${sim.reason}` }
+        const gasPrice = await getGasPriceWithFloor(ctx.publicClient)
+        const txHash = await ctx.walletClient.writeContract({
+          address: pool,
+          abi: AAVE_V3_POOL_ABI,
+          functionName: 'repay',
+          args: repayArgs,
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            token: token.symbol,
+            amount: args.amount,
+            status: receipt.status === 'success' ? 'success' : 'reverted',
+            healthFactorAfter: await healthFactorAfter(ctx, pool),
+            simGasEstimate: sim.gas.toString(),
+            policyEnforced: ctx.policy != null,
+            ...(allow.txHash ? { approveTxHash: allow.txHash } : {}),
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+const WithdrawSchema = z.object({
+  token: z.string().min(1).describe('ERC-20 symbol or 0x address to withdraw.'),
+  amount: z
+    .string()
+    .min(1)
+    .describe('Amount in token units, or "max" for the full supplied balance.'),
+})
+type WithdrawArgs = z.infer<typeof WithdrawSchema>
+
+export function makeAaveWithdraw(ctx: OnchainRuntimeContext): ToolDef<WithdrawArgs> {
+  return {
+    name: 'aave.withdraw',
+    description:
+      'Withdraw a supplied ERC-20 from Aave V3 on Mantle. Use "max" for the full balance. Aave reverts a withdraw that would breach your health factor; the pre-flight simulation surfaces that before any tx.',
+    searchHint: 'aave withdraw redeem unwind collateral',
+    schema: WithdrawSchema,
+    handler: async args => {
+      try {
+        const pool = requirePool(ctx)
+        const account = ctx.walletClient.account
+        if (!account) return { ok: false, error: 'walletClient has no account; cannot withdraw' }
+        const token = await resolveToken({
+          client: ctx.publicClient,
+          agentDir: ctx.agentDir,
+          input: args.token,
+        })
+        if (!token) return { ok: false, error: `unknown token: ${args.token}` }
+        const amount =
+          args.amount.toLowerCase() === 'max'
+            ? AAVE_MAX_WITHDRAW
+            : parseUnits(args.amount, token.decimals)
+        if (ctx.policy && amount !== AAVE_MAX_WITHDRAW) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: token.address, amountRaw: amount },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: pool,
+          abi: AAVE_V3_POOL_ABI as Abi,
+          functionName: 'withdraw',
+          args: [token.address, amount, ctx.agentEoa],
+        })
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation reverted: ${sim.reason}` }
+        const gasPrice = await getGasPriceWithFloor(ctx.publicClient)
+        const txHash = await ctx.walletClient.writeContract({
+          address: pool,
+          abi: AAVE_V3_POOL_ABI,
+          functionName: 'withdraw',
+          args: [token.address, amount, ctx.agentEoa],
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            token: token.symbol,
+            amount: args.amount,
+            status: receipt.status === 'success' ? 'success' : 'reverted',
+            simGasEstimate: sim.gas.toString(),
+            policyEnforced: ctx.policy != null,
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}