lyra-plugin-onchain 0.1.5 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-plugin-onchain",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "type": "module",
   "description": "The Sui on-chain tools for Lyra: SUI transfers, DeepBook market data, Walrus receipts/memory — every write policy-checked, simulated, and recorded on-chain via lyra::policy",
   "license": "MIT",
@@ -13,28 +13,14 @@
   "bugs": {
     "url": "https://github.com/rifkyeasy/lyra/issues"
   },
-  "keywords": [
-    "lyra",
-    "ai",
-    "agent",
-    "sui",
-    "defi",
-    "deepbook",
-    "walrus",
-    "policy",
-    "plugin"
-  ],
+  "keywords": ["lyra", "ai", "agent", "sui", "defi", "deepbook", "walrus", "policy", "plugin"],
   "publishConfig": {
     "access": "public"
   },
   "engines": {
     "bun": ">=1.1"
   },
-  "files": [
-    "src",
-    "!src/**/*.test.ts",
-    "README.md"
-  ],
+  "files": ["src", "!src/**/*.test.ts", "README.md"],
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -47,7 +33,10 @@
     "@mysten/deepbook-v3": "^0.18.0",
     "@mysten/sui": "^1.40.0",
     "@mysten/walrus": "^0.6.4",
+    "@pythnetwork/pyth-sui-js": "2.2.0",
     "@scallop-io/sui-scallop-sdk": "^2.4.5",
+    "@suilend/sdk": "1.1.99",
+    "@suilend/sui-fe": "0.3.49",
     "lyra-core": "^0.1.2",
     "navi-sdk": "^1.7.3",
     "zod": "^3.23.8"

package/src/index.ts

@@ -25,16 +25,34 @@ import { makeAccountInfo, makeSuiBalance } from './tools/balance'
 import { makeCetusQuote } from './tools/cetus'
 import { makeDeepbookMarkets } from './tools/deepbook'
 import { makeDefiYields } from './tools/defillama'
-import { makeNaviMarkets, makeNaviPosition, makeNaviSupply, makeNaviWithdraw } from './tools/navi'
+import { makeVoloStake, makeVoloUnstake } from './tools/liquid-stake'
+import {
+  makeNaviBorrow,
+  makeNaviMarkets,
+  makeNaviPosition,
+  makeNaviRepay,
+  makeNaviSupply,
+  makeNaviWithdraw,
+} from './tools/navi'
 import { makePolicyCreate, makePolicyShow } from './tools/policy'
 import { makeProtocolsList } from './tools/protocols'
 import {
+  makeScallopBorrow,
   makeScallopMarkets,
   makeScallopPosition,
+  makeScallopRepay,
   makeScallopSupply,
   makeScallopWithdraw,
 } from './tools/scallop'
 import { makeSuiSend } from './tools/send'
+import { makeStake, makeUnstake } from './tools/stake'
+import {
+  makeSuilendBorrow,
+  makeSuilendPosition,
+  makeSuilendRepay,
+  makeSuilendSupply,
+  makeSuilendWithdraw,
+} from './tools/suilend'
 import { makeSwap } from './tools/swap'
 import { makeWalrusStore } from './tools/walrus'
 import type { OnchainRuntimeContext } from './types'
@@ -87,10 +105,25 @@ const plugin: NativePlugin = {
     ctx.registerTool(makeScallopPosition(onchain) as ToolDef)
     ctx.registerTool(makeScallopSupply(onchain) as ToolDef)
     ctx.registerTool(makeScallopWithdraw(onchain) as ToolDef)
+    ctx.registerTool(makeScallopBorrow(onchain) as ToolDef)
+    ctx.registerTool(makeScallopRepay(onchain) as ToolDef)
     ctx.registerTool(makeNaviMarkets(onchain) as ToolDef)
     ctx.registerTool(makeNaviPosition(onchain) as ToolDef)
     ctx.registerTool(makeNaviSupply(onchain) as ToolDef)
     ctx.registerTool(makeNaviWithdraw(onchain) as ToolDef)
+    ctx.registerTool(makeNaviBorrow(onchain) as ToolDef)
+    ctx.registerTool(makeNaviRepay(onchain) as ToolDef)
+    ctx.registerTool(makeSuilendSupply(onchain) as ToolDef)
+    ctx.registerTool(makeSuilendWithdraw(onchain) as ToolDef)
+    ctx.registerTool(makeSuilendBorrow(onchain) as ToolDef)
+    ctx.registerTool(makeSuilendRepay(onchain) as ToolDef)
+    ctx.registerTool(makeSuilendPosition(onchain) as ToolDef)
+
+    // Staking: native delegation (min 1 SUI) + Volo liquid staking (vSUI).
+    ctx.registerTool(makeStake(onchain) as ToolDef)
+    ctx.registerTool(makeUnstake(onchain) as ToolDef)
+    ctx.registerTool(makeVoloStake(onchain) as ToolDef)
+    ctx.registerTool(makeVoloUnstake(onchain) as ToolDef)
   },
 }
 

package/src/minimums.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test'
+import { MIN_MIST, checkMinimum } from './minimums'
+
+describe('checkMinimum', () => {
+  test('rejects a too-small stake (0.1 SUI < 1 SUI minimum)', () => {
+    const err = checkMinimum('stake', 100_000_000n) // 0.1 SUI
+    expect(err).not.toBeNull()
+    expect(err).toContain('amount too small')
+    expect(err).toContain('1 SUI minimum for stake')
+  })
+
+  test('accepts a stake at the 1 SUI minimum', () => {
+    expect(checkMinimum('stake', MIN_MIST.stake)).toBeNull()
+    expect(checkMinimum('stake', 2_000_000_000n)).toBeNull()
+  })
+
+  test('rejects dust transfers/swaps/supplies below their minimums', () => {
+    expect(checkMinimum('transfer', 1n)).not.toBeNull()
+    expect(checkMinimum('swap', 1_000_000n)).not.toBeNull() // 0.001 < 0.01
+    expect(checkMinimum('supply', 5_000_000n)).not.toBeNull() // 0.005 < 0.01
+    expect(checkMinimum('borrow', 9_999_999n)).not.toBeNull()
+  })
+
+  test('accepts amounts at/above the minimum', () => {
+    expect(checkMinimum('transfer', MIN_MIST.transfer)).toBeNull()
+    expect(checkMinimum('swap', MIN_MIST.swap)).toBeNull()
+    expect(checkMinimum('supply', MIN_MIST.supply)).toBeNull()
+    expect(checkMinimum('borrow', MIN_MIST.borrow)).toBeNull()
+  })
+
+  test('the message names the amount, the minimum, and the action', () => {
+    const err = checkMinimum('swap', 5_000_000n) // 0.005 SUI
+    expect(err).toContain('0.005 SUI')
+    expect(err).toContain('0.01 SUI minimum for swap')
+  })
+})

package/src/minimums.ts

@@ -0,0 +1,35 @@
+/**
+ * Per-action minimum amounts (in MIST). Below these an on-chain call either
+ * hard-aborts (Sui native staking requires ≥ 1 SUI) or is economically
+ * pointless (dust deposits). We reject BEFORE building/simulating/executing and
+ * tell the user the minimum — so a too-small amount returns a clear
+ * "amount too small" error instead of a doomed transaction that could otherwise
+ * look like it succeeded.
+ */
+export const MIN_MIST = {
+  transfer: 1_000_000n, // 0.001 SUI
+  swap: 10_000_000n, // 0.01 SUI
+  supply: 10_000_000n, // 0.01 SUI  (lending deposit)
+  borrow: 10_000_000n, // 0.01 SUI
+  stake: 1_000_000_000n, // 1 SUI    (Sui native staking hard minimum)
+} as const
+
+export type MinAction = keyof typeof MIN_MIST
+
+const fmtSui = (mist: bigint): string => {
+  const s = (Number(mist) / 1e9).toString()
+  return s
+}
+
+/**
+ * Returns an error string when `amountMist` is below the action's minimum,
+ * otherwise null. Callers should early-return the string as `{ ok: false, error }`
+ * BEFORE executing anything.
+ */
+export function checkMinimum(action: MinAction, amountMist: bigint): string | null {
+  const min = MIN_MIST[action]
+  if (amountMist < min) {
+    return `amount too small: ${fmtSui(amountMist)} SUI is below the ${fmtSui(min)} SUI minimum for ${action} — try at least ${fmtSui(min)} SUI`
+  }
+  return null
+}

package/src/protocols.ts

@@ -43,7 +43,7 @@ export const PROTOCOLS: ProtocolCapability[] = [
     execute: false,
     tools: ['deepbook.markets'],
     llamaProjects: ['deepbook'],
-    note: 'market data read; on-chain order execution not wired yet',
+    note: 'market data read; swaps route through DeepBook via the 7k aggregator',
   },
   {
     id: 'scallop',
@@ -51,8 +51,16 @@ export const PROTOCOLS: ProtocolCapability[] = [
     category: 'lending',
     read: true,
     execute: true,
-    tools: ['scallop.markets', 'scallop.position', 'scallop.supply', 'scallop.withdraw'],
+    tools: [
+      'scallop.markets',
+      'scallop.position',
+      'scallop.supply',
+      'scallop.withdraw',
+      'scallop.borrow',
+      'scallop.repay',
+    ],
     llamaProjects: ['scallop-lending', 'scallop'],
+    note: 'full supply / withdraw / borrow / repay',
   },
   {
     id: 'navi',
@@ -60,13 +68,55 @@ export const PROTOCOLS: ProtocolCapability[] = [
     category: 'lending',
     read: true,
     execute: true,
-    tools: ['navi.markets', 'navi.position', 'navi.supply', 'navi.withdraw'],
+    tools: [
+      'navi.markets',
+      'navi.position',
+      'navi.supply',
+      'navi.withdraw',
+      'navi.borrow',
+      'navi.repay',
+    ],
     llamaProjects: ['navi-lending', 'navi-protocol', 'navi'],
-    note: 'largest Sui lending market by TVL',
+    note: 'largest Sui lending market by TVL; full supply / withdraw / borrow / repay',
+  },
+  {
+    id: 'suilend',
+    name: 'Suilend',
+    category: 'lending',
+    read: true,
+    execute: true,
+    tools: [
+      'suilend.position',
+      'suilend.supply',
+      'suilend.withdraw',
+      'suilend.borrow',
+      'suilend.repay',
+    ],
+    llamaProjects: ['suilend'],
+    note: 'MAIN_POOL market; full supply / withdraw / borrow / repay',
+  },
+  {
+    id: 'native-staking',
+    name: 'Sui Native Staking',
+    category: 'staking',
+    read: false,
+    execute: true,
+    tools: ['sui.stake', 'sui.unstake'],
+    note: 'delegate SUI to a validator (min 1 SUI); classic staking rewards',
+  },
+  {
+    id: 'volo',
+    name: 'Volo (Liquid Staking)',
+    category: 'staking',
+    read: false,
+    execute: true,
+    tools: ['volo.stake', 'volo.unstake'],
+    llamaProjects: ['volo', 'volo-staked-sui'],
+    note: 'stake SUI → vSUI, a liquid staking token usable across DeFi while earning',
   },
   {
     id: 'aggregator',
-    name: 'DEX aggregator (7k / Cetus / FlowX / Bluefin)',
+    name: 'DEX aggregator (7k best-route)',
     category: 'aggregator',
     read: true,
     execute: true,
@@ -81,8 +131,12 @@ export const PROTOCOLS: ProtocolCapability[] = [
       'bluefin',
       'turbos',
       'kriya-dex',
+      'aftermath-amm',
+      'aftermath',
+      'momentum',
+      'mmt',
     ],
-    note: 'swap executes via the 7k aggregator, routing across Cetus/FlowX/Bluefin/DeepBook',
+    note: 'swap executes via the 7k aggregator, routing best price across Cetus / Turbos / FlowX / Bluefin / Aftermath / Momentum / Kriya / DeepBook',
   },
 ]
 

package/src/tools/liquid-stake.ts

@@ -0,0 +1,152 @@
+/**
+ * Volo liquid staking — stake SUI for vSUI (a liquid staking token that keeps
+ * earning while remaining tradeable / usable in DeFi), and unstake vSUI back to
+ * SUI. Built on navi-sdk's Volo PTB helpers.
+ *
+ *   volo.stake   → SUI → vSUI  (stake_pool::stake)
+ *   volo.unstake → vSUI → SUI  (stake_pool::unstake)
+ *
+ * Same guarded pipeline: minimum guard → policy → dry-run simulate → execute →
+ * on-chain effects check.
+ */
+
+import { Transaction, coinWithBalance } from '@mysten/sui/transactions'
+import type { ToolDef } from 'lyra-core'
+import { stakeTovSuiPTB, unstakeTovSui } from 'navi-sdk'
+import { z } from 'zod'
+import { checkMinimum } from '../minimums'
+import { evaluatePolicy, suiToMist } from '../policy'
+import { simulate } from '../simulate'
+import type { OnchainRuntimeContext } from '../types'
+
+const SUI_TYPE = '0x2::sui::SUI'
+const VSUI_TYPE = '0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT'
+
+const StakeSchema = z.object({
+  amount: z.string().min(1).describe('Amount of SUI to liquid-stake (minimum 1 SUI).'),
+})
+type StakeArgs = z.infer<typeof StakeSchema>
+
+const UnstakeSchema = z.object({
+  amount: z.string().min(1).describe('Amount of vSUI to unstake back to SUI.'),
+})
+type UnstakeArgs = z.infer<typeof UnstakeSchema>
+
+export function makeVoloStake(ctx: OnchainRuntimeContext): ToolDef<StakeArgs> {
+  return {
+    name: 'volo.stake',
+    description:
+      'Liquid-stake SUI with Volo and receive vSUI — a liquid staking token that keeps earning staking rewards while remaining tradeable and usable across Sui DeFi (unlike native staking, which locks the position). Minimum 1 SUI. Policy-checked, simulated, then executed.',
+    searchHint:
+      'volo liquid stake vsui lst liquid-staking derivative earn yield tradeable sui defi',
+    schema: StakeSchema,
+    handler: async args => {
+      try {
+        if (ctx.network !== 'mainnet') return { ok: false, error: 'Volo supports mainnet only' }
+        const amountMist = suiToMist(args.amount)
+        if (amountMist === undefined || amountMist <= 0n) {
+          return { ok: false, error: `invalid amount "${args.amount}"` }
+        }
+        const tooSmall = checkMinimum('stake', amountMist)
+        if (tooSmall) return { ok: false, error: tooSmall }
+
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', coinType: SUI_TYPE, amountMist, protocol: 'stake' },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+
+        const tx = new Transaction()
+        const [suiCoin] = tx.splitCoins(tx.gas, [amountMist])
+        const vsui = await stakeTovSuiPTB(tx as never, suiCoin as never)
+        tx.transferObjects([vsui as never], ctx.agentAddress)
+
+        const sim = await simulate(ctx.client, tx, ctx.agentAddress)
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation failed: ${sim.reason}` }
+
+        const res = await ctx.client.signAndExecuteTransaction({
+          signer: ctx.keypair,
+          transaction: tx,
+          options: { showEffects: true },
+        })
+        if (res.effects?.status?.status !== 'success') {
+          return {
+            ok: false,
+            error: `execution failed: ${res.effects?.status?.error ?? 'unknown'}`,
+          }
+        }
+        await ctx.client.waitForTransaction({ digest: res.digest })
+        return {
+          ok: true,
+          data: {
+            protocol: 'volo',
+            action: 'liquid-stake',
+            amountSui: args.amount,
+            received: 'vSUI',
+            digest: res.digest,
+            status: 'success',
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+export function makeVoloUnstake(ctx: OnchainRuntimeContext): ToolDef<UnstakeArgs> {
+  return {
+    name: 'volo.unstake',
+    description:
+      'Unstake vSUI back to SUI via Volo (returns SUI including accrued staking rewards). The amount is denominated in vSUI. Simulated, then executed.',
+    searchHint: 'volo unstake vsui redeem convert back sui liquid staking withdraw',
+    schema: UnstakeSchema,
+    handler: async args => {
+      try {
+        if (ctx.network !== 'mainnet') return { ok: false, error: 'Volo supports mainnet only' }
+        const amountMist = suiToMist(args.amount)
+        if (amountMist === undefined || amountMist <= 0n) {
+          return { ok: false, error: `invalid amount "${args.amount}"` }
+        }
+
+        const tx = new Transaction()
+        // coinWithBalance resolves the agent's vSUI coins into one of the exact size.
+        const vsuiCoin = coinWithBalance({ type: VSUI_TYPE, balance: amountMist })
+        const sui = await unstakeTovSui(tx as never, vsuiCoin as never)
+        tx.transferObjects([sui as never], ctx.agentAddress)
+
+        const sim = await simulate(ctx.client, tx, ctx.agentAddress)
+        if (!sim.ok) return { ok: false, error: `pre-flight simulation failed: ${sim.reason}` }
+
+        const res = await ctx.client.signAndExecuteTransaction({
+          signer: ctx.keypair,
+          transaction: tx,
+          options: { showEffects: true },
+        })
+        if (res.effects?.status?.status !== 'success') {
+          return {
+            ok: false,
+            error: `execution failed: ${res.effects?.status?.error ?? 'unknown'}`,
+          }
+        }
+        await ctx.client.waitForTransaction({ digest: res.digest })
+        return {
+          ok: true,
+          data: {
+            protocol: 'volo',
+            action: 'unstake',
+            amountVsui: args.amount,
+            digest: res.digest,
+            status: 'success',
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}

package/src/tools/navi.ts

@@ -10,8 +10,9 @@
 
 import { Transaction } from '@mysten/sui/transactions'
 import type { ToolDef } from 'lyra-core'
-import { NAVISDKClient, depositCoin, pool, withdrawCoin } from 'navi-sdk'
+import { NAVISDKClient, borrowCoin, depositCoin, pool, repayDebt, withdrawCoin } from 'navi-sdk'
 import { z } from 'zod'
+import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
@@ -107,17 +108,30 @@ type AmountArgs = z.infer<typeof AmountSchema>
 async function runNaviWrite(
   ctx: OnchainRuntimeContext,
   amount: string,
-  kind: 'supply' | 'withdraw',
+  kind: 'supply' | 'withdraw' | 'borrow' | 'repay',
 ): Promise<{ ok: true; data: unknown } | { ok: false; error: string }> {
   const err = ensureMainnet(ctx)
   if (err) return { ok: false, error: err }
   const amountMist = suiToMist(amount)
   if (amountMist === undefined || amountMist <= 0n)
     return { ok: false, error: `invalid amount "${amount}"` }
+  // Minimum guard for value-moving actions (withdraw brings value back in).
+  const minAction = kind === 'borrow' ? 'borrow' : kind === 'withdraw' ? null : 'supply'
+  if (minAction) {
+    const tooSmall = checkMinimum(minAction, amountMist)
+    if (tooSmall) return { ok: false, error: tooSmall }
+  }
 
-  if (ctx.policy && kind === 'supply') {
+  // Policy gate on value-moving actions (borrow creates debt + hands out funds;
+  // repay/supply move SUI out). Withdraw pulls the agent's own funds back.
+  if (ctx.policy && kind !== 'withdraw') {
     const verdict = evaluatePolicy(
-      { kind: 'transfer', coinType: SUI_TYPE, amountMist, protocol: 'navi' },
+      {
+        kind: 'transfer',
+        coinType: SUI_TYPE,
+        amountMist,
+        protocol: kind === 'borrow' ? 'borrow' : 'navi',
+      },
       ctx.policy,
     )
     if (!verdict.allowed)
@@ -130,11 +144,19 @@ async function runNaviWrite(
     if (kind === 'supply') {
       const [coin] = tx.splitCoins(tx.gas, [amountMist])
       await depositCoin(tx as never, suiPool as never, coin as never, Number(amountMist))
-    } else {
+    } else if (kind === 'withdraw') {
       // navi-sdk's withdrawCoin already wraps the withdrawn Balance into a Coin
       // (via coin::from_balance) and returns [coin]; destructure and transfer it.
       const [coin] = await withdrawCoin(tx as never, suiPool as never, Number(amountMist))
       tx.transferObjects([coin as never], ctx.agentAddress)
+    } else if (kind === 'borrow') {
+      // Borrow against supplied collateral; hand the borrowed coin to the agent.
+      const [coin] = await borrowCoin(tx as never, suiPool as never, Number(amountMist))
+      tx.transferObjects([coin as never], ctx.agentAddress)
+    } else {
+      // repay: split the repayment from gas and pay down the debt.
+      const [coin] = tx.splitCoins(tx.gas, [amountMist])
+      await repayDebt(tx as never, suiPool as never, coin as never, Number(amountMist))
     }
 
     const sim = await simulate(ctx.client, tx, ctx.agentAddress)
@@ -187,3 +209,24 @@ export function makeNaviWithdraw(ctx: OnchainRuntimeContext): ToolDef<AmountArgs
     handler: async args => runNaviWrite(ctx, args.amount, 'withdraw'),
   }
 }
+
+export function makeNaviBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
+  return {
+    name: 'navi.borrow',
+    description:
+      'Borrow SUI from NAVI against supplied collateral. Requires an existing supply position with enough health factor; the pre-flight simulation fails cleanly if under-collateralized. Policy-checked, simulated, then executed.',
+    searchHint: 'navi borrow loan leverage debt against collateral sui',
+    schema: AmountSchema,
+    handler: async args => runNaviWrite(ctx, args.amount, 'borrow'),
+  }
+}
+
+export function makeNaviRepay(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
+  return {
+    name: 'navi.repay',
+    description: 'Repay borrowed SUI debt on NAVI. Simulated, then executed.',
+    searchHint: 'navi repay pay back debt loan close sui',
+    schema: AmountSchema,
+    handler: async args => runNaviWrite(ctx, args.amount, 'repay'),
+  }
+}

package/src/tools/onchain.integration.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Integration coverage — LIVE mainnet dry-runs (devInspect, never broadcast).
+ *
+ * Gated: runs only when `LYRA_RUN_INTEGRATION=1` and a real `LYRA_AGENT_KEY` is
+ * present. In CI (no secret) the whole suite is skipped, so it never flakes the
+ * default `bun test`. Run locally with:
+ *
+ *   LYRA_RUN_INTEGRATION=1 bun test src/tools/onchain.integration.test.ts
+ *
+ * Each write case builds the exact PTB its tool builds and simulates it against
+ * mainnet, proving the SDK integration + PTB are valid on-chain without moving
+ * funds. Read-only tools are invoked directly (safe).
+ */
+
+import { describe, expect, test } from 'bun:test'
+import { Transaction } from '@mysten/sui/transactions'
+import { LENDING_MARKET_ID, LENDING_MARKET_TYPE, SuilendClient } from '@suilend/sdk'
+import { stakeTovSuiPTB } from 'navi-sdk'
+import { keypairFromSecret, makeSuiClient } from '../client'
+import type { OnchainRuntimeContext } from '../types'
+import { makeScallopMarkets } from './scallop'
+import { makeSuilendPosition } from './suilend'
+
+const SUI = '0x2::sui::SUI'
+const RUN = process.env.LYRA_RUN_INTEGRATION === '1' && !!process.env.LYRA_AGENT_KEY
+const ONE_SUI = 1_000_000_000n
+
+function realCtx(): OnchainRuntimeContext {
+  const client = makeSuiClient('mainnet')
+  const keypair = keypairFromSecret(process.env.LYRA_AGENT_KEY as string)
+  return {
+    client,
+    keypair,
+    agentAddress: keypair.getPublicKey().toSuiAddress(),
+    network: 'mainnet',
+    agentDir: '/tmp/lyra-integration',
+  }
+}
+
+async function simStatus(ctx: OnchainRuntimeContext, tx: Transaction): Promise<string | undefined> {
+  const r = await ctx.client.devInspectTransactionBlock({
+    sender: ctx.agentAddress,
+    transactionBlock: tx as never,
+  })
+  return r.effects?.status?.status
+}
+
+describe.skipIf(!RUN)('mainnet dry-run integration', () => {
+  test('native stake (1 SUI → validator) simulates success', async () => {
+    const ctx = realCtx()
+    const state = await ctx.client.getLatestSuiSystemState()
+    const validator = state.activeValidators
+      .slice()
+      .sort((a, b) => Number(b.votingPower) - Number(a.votingPower))[0]
+    if (!validator) throw new Error('no active validators')
+    const tx = new Transaction()
+    tx.setSender(ctx.agentAddress)
+    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
+    tx.moveCall({
+      target: '0x3::sui_system::request_add_stake',
+      arguments: [tx.object('0x5'), coin, tx.pure.address(validator.suiAddress)],
+    })
+    expect(await simStatus(ctx, tx)).toBe('success')
+  }, 45_000)
+
+  test('Volo liquid stake (1 SUI → vSUI) simulates success', async () => {
+    const ctx = realCtx()
+    const tx = new Transaction()
+    tx.setSender(ctx.agentAddress)
+    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
+    const vsui = await stakeTovSuiPTB(tx as never, coin as never)
+    tx.transferObjects([vsui as never], ctx.agentAddress)
+    expect(await simStatus(ctx, tx)).toBe('success')
+  }, 45_000)
+
+  test('Suilend supply (1 SUI) simulates success', async () => {
+    const ctx = realCtx()
+    const suilend = await SuilendClient.initialize(
+      LENDING_MARKET_ID,
+      LENDING_MARKET_TYPE,
+      ctx.client as never,
+    )
+    const caps = await SuilendClient.getObligationOwnerCaps(
+      ctx.agentAddress,
+      [LENDING_MARKET_TYPE],
+      ctx.client as never,
+    )
+    const tx = new Transaction()
+    tx.setSender(ctx.agentAddress)
+    const [coin] = tx.splitCoins(tx.gas, [ONE_SUI])
+    if (caps.length === 0) {
+      const cap = suilend.createObligation(tx as never)
+      suilend.deposit(coin as never, SUI, cap, tx as never)
+      tx.transferObjects([cap as never], ctx.agentAddress)
+    } else {
+      const c = caps[0] as { id: string | { id: string } }
+      const capId = typeof c.id === 'string' ? c.id : c.id.id
+      suilend.deposit(coin as never, SUI, capId, tx as never)
+    }
+    expect(await simStatus(ctx, tx)).toBe('success')
+  }, 45_000)
+
+  test('read-only tools return live data', async () => {
+    const ctx = realCtx()
+    const position = await makeSuilendPosition(ctx).handler({})
+    expect(position.ok).toBe(true)
+
+    const markets = await makeScallopMarkets(ctx).handler({ coins: 'sui' })
+    expect(markets.ok).toBe(true)
+  }, 45_000)
+})