nebula-ai-plugin-onchain 0.1.0

package/src/tools/wrap.ts

@@ -0,0 +1,183 @@
+/**
+ * `chain.wrap` + `chain.unwrap` — native MNT ↔ WMNT via WETH9 deposit/withdraw.
+ */
+
+import type { ToolDef } from 'nebula-ai-core'
+import { getGasPriceWithFloor } from 'nebula-ai-core'
+import { type Abi, type Address, formatEther, parseEther } from 'viem'
+import { z } from 'zod'
+import { WETH9_ABI } from '../abis'
+import { AGNI_BY_NETWORK, requireMainnet } from '../constants'
+import { evaluatePolicy } from '../policy'
+import { simulateContractWrite } from '../simulate'
+import type { OnchainRuntimeContext } from '../types'
+import { waitForReceipt } from '../wait-receipt'
+
+const WrapSchema = z.object({
+  amount: z.string().min(1).describe('Amount of MNT to wrap (e.g. "0.05").'),
+})
+type WrapArgs = z.infer<typeof WrapSchema>
+
+export function makeChainWrap(ctx: OnchainRuntimeContext): ToolDef<WrapArgs> {
+  return {
+    name: 'chain.wrap',
+    description:
+      'Wrap native MNT into WMNT (ERC-20). Calls WMNT.deposit() with msg.value. Required when the agent needs to swap with ERC-20 input on Agni.',
+    searchHint: 'wrap wmnt weth deposit erc20 mnt',
+    schema: WrapSchema,
+    handler: async args => {
+      try {
+        requireMainnet(ctx.network)
+        const wmnt = AGNI_BY_NETWORK[ctx.network]!.weth9
+        const account = ctx.walletClient.account
+        if (!account) {
+          return { ok: false, error: 'walletClient has no account; cannot wrap' }
+        }
+        const value = parseEther(args.amount)
+        // Policy + simulate, same as every other value-moving write.
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: 'native', amountRaw: value },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: wmnt as Address,
+          abi: WETH9_ABI as Abi,
+          functionName: 'deposit',
+          args: [],
+          value,
+        })
+        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: wmnt as Address,
+          abi: WETH9_ABI,
+          functionName: 'deposit',
+          value,
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        const wmntBal = (await ctx.publicClient.readContract({
+          address: wmnt as Address,
+          abi: WETH9_ABI,
+          functionName: 'balanceOf',
+          args: [ctx.agentEoa],
+        })) as bigint
+        const nativeBal = await ctx.publicClient.getBalance({ address: ctx.agentEoa })
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            gasUsed: receipt.gasUsed.toString(),
+            wrappedAmount: args.amount,
+            wmntBalance: formatEther(wmntBal),
+            nativeBalance: formatEther(nativeBal),
+            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) }
+      }
+    },
+  }
+}
+
+const UnwrapSchema = z.object({
+  amount: z.string().min(1).describe('Amount of WMNT to unwrap, or "all" for entire WMNT balance.'),
+})
+type UnwrapArgs = z.infer<typeof UnwrapSchema>
+
+export function makeChainUnwrap(ctx: OnchainRuntimeContext): ToolDef<UnwrapArgs> {
+  return {
+    name: 'chain.unwrap',
+    description:
+      'Unwrap WMNT back into native MNT. Calls WMNT.withdraw(amount). Pass "all" to unwrap entire balance.',
+    searchHint: 'unwrap wmnt native withdraw mnt',
+    schema: UnwrapSchema,
+    handler: async args => {
+      try {
+        requireMainnet(ctx.network)
+        const wmnt = AGNI_BY_NETWORK[ctx.network]!.weth9
+        const account = ctx.walletClient.account
+        if (!account) {
+          return { ok: false, error: 'walletClient has no account; cannot unwrap' }
+        }
+        let amountWei: bigint
+        if (args.amount === 'all') {
+          amountWei = (await ctx.publicClient.readContract({
+            address: wmnt as Address,
+            abi: WETH9_ABI,
+            functionName: 'balanceOf',
+            args: [ctx.agentEoa],
+          })) as bigint
+          if (amountWei === 0n) {
+            return { ok: false, error: 'no WMNT balance to unwrap' }
+          }
+        } else {
+          amountWei = parseEther(args.amount)
+        }
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', asset: 'native', amountRaw: amountWei },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+        const sim = await simulateContractWrite(ctx.publicClient, {
+          account: account.address,
+          address: wmnt as Address,
+          abi: WETH9_ABI as Abi,
+          functionName: 'withdraw',
+          args: [amountWei],
+        })
+        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: wmnt as Address,
+          abi: WETH9_ABI,
+          functionName: 'withdraw',
+          args: [amountWei],
+          chain: ctx.walletClient.chain,
+          account,
+          gasPrice,
+        })
+        const receipt = await waitForReceipt(ctx.publicClient, txHash)
+        const wmntBal = (await ctx.publicClient.readContract({
+          address: wmnt as Address,
+          abi: WETH9_ABI,
+          functionName: 'balanceOf',
+          args: [ctx.agentEoa],
+        })) as bigint
+        const nativeBal = await ctx.publicClient.getBalance({ address: ctx.agentEoa })
+        return {
+          ok: true,
+          data: {
+            txHash,
+            blockNumber: Number(receipt.blockNumber),
+            gasUsed: receipt.gasUsed.toString(),
+            unwrappedAmount: formatEther(amountWei),
+            wmntBalance: formatEther(wmntBal),
+            nativeBalance: formatEther(nativeBal),
+            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) }
+      }
+    },
+  }
+}

package/src/types.ts

@@ -0,0 +1,53 @@
+/**
+ * Public types exported from plugin-onchain. The runtime context follows the
+ * same side-band pattern as `plugin-comms/src/index.ts:CommsRuntimeContext`:
+ * the harness builds it in `chat.tsx`, the plugin reads it via
+ * `(ctx as any).onchain`. Keeps PluginContext clean of plugin-specific fields.
+ */
+
+import type { NebulaNetwork } from 'nebula-ai-core'
+import type { Address } from 'viem'
+import type { OnchainPolicy } from './policy'
+
+export interface OnchainRuntimeContext {
+  agentEoa: Address
+  network: NebulaNetwork
+  /** Deterministic fund-control policy. When set, every write is checked before simulate/execute. */
+  policy?: OnchainPolicy
+  publicClient: import('viem').PublicClient
+  walletClient: import('viem').WalletClient
+  agentDir: string
+  /** iNFT mint block — used as floor for Transfer-event discovery scans. */
+  mintBlock: bigint
+  iNFT?: { contract: Address; tokenId: bigint }
+  /** Optional: brain provider/model for account.info bundling. */
+  brainProvider?: string | null
+  brainModel?: string | null
+}
+
+export interface TokenInfo {
+  address: Address
+  symbol: string
+  name?: string
+  decimals: number
+  /** Where this entry came from. */
+  source: 'cache' | 'list' | 'onchain' | 'native'
+}
+
+export interface NativeBalance {
+  raw: string // bigint serialized as decimal string
+  formatted: string // human "1.234"
+}
+
+export interface TokenBalance extends TokenInfo {
+  raw: string
+  formatted: string
+}
+
+export interface BalanceSnapshot {
+  address: Address
+  native: NativeBalance
+  tokens: TokenBalance[]
+  /** Block at which the snapshot was taken. */
+  blockNumber: number
+}

package/src/wait-receipt.ts

@@ -0,0 +1,34 @@
+/**
+ * Wrapper for viem's `waitForTransactionReceipt` with Mantle-mainnet-tuned
+ * polling. The default 4s poll occasionally times out on Mantle even when the
+ * tx lands in 1-2s; we bump to 1.5s with a generous retry budget. The
+ * helper also catches viem's `TransactionReceiptNotFoundError` (intermittent
+ * RPC null responses immediately after inclusion) and retries.
+ */
+
+import type { Hex, PublicClient, TransactionReceipt } from 'viem'
+
+const DEFAULT_TIMEOUT_MS = 90_000
+const DEFAULT_POLL_MS = 1_500
+
+export async function waitForReceipt(
+  client: PublicClient,
+  hash: Hex,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<TransactionReceipt> {
+  const start = Date.now()
+  let lastErr: unknown
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const r = await client.getTransactionReceipt({ hash })
+      return r
+    } catch (e) {
+      lastErr = e
+      // intermittent "not found" — keep polling
+    }
+    await new Promise(r => setTimeout(r, DEFAULT_POLL_MS))
+  }
+  throw new Error(
+    `tx receipt timeout after ${timeoutMs}ms for ${hash}; lastErr=${(lastErr as Error)?.message ?? 'unknown'}`,
+  )
+}