lyra-plugin-onchain 0.1.2 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-plugin-onchain",
-  "version": "0.1.2",
+  "version": "0.1.7",
   "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",

package/src/capture-shim.ts

@@ -0,0 +1,20 @@
+// Bun's `Error.captureStackTrace` throws "First argument must be an Error object"
+// for some calls `follow-redirects` makes at module-init time. follow-redirects is
+// pulled in by axios → navi-sdk (imported statically by ./tools/navi), so loading
+// this plugin under Bun used to crash the host (e.g. `lyra` chat, the gateway).
+//
+// Guard captureStackTrace so such calls are a harmless no-op instead of throwing —
+// the affected error objects just won't carry a V8-captured stack. MUST be the
+// first import in this package's entry, before anything pulls in navi-sdk.
+const original = Error.captureStackTrace
+if (typeof original === 'function') {
+  Error.captureStackTrace = ((target: object, ctor?: unknown) => {
+    try {
+      ;(original as (t: object, c?: unknown) => void).call(Error, target, ctor)
+    } catch {
+      // Bun rejects some non-Error targets here — ignore.
+    }
+  }) as typeof Error.captureStackTrace
+}
+
+export {}

package/src/index.ts

@@ -17,12 +17,22 @@
  * nothing — a graceful no-op for unit-test loaders.
  */
 
+// MUST be first: guards Error.captureStackTrace before ./tools/navi pulls in
+// navi-sdk → axios → follow-redirects, which crashes Bun at import otherwise.
+import './capture-shim'
 import type { NativePlugin, ToolDef } from 'lyra-core'
 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 {
+  makeNaviBorrow,
+  makeNaviMarkets,
+  makeNaviPosition,
+  makeNaviRepay,
+  makeNaviSupply,
+  makeNaviWithdraw,
+} from './tools/navi'
 import { makePolicyCreate, makePolicyShow } from './tools/policy'
 import { makeProtocolsList } from './tools/protocols'
 import {
@@ -32,6 +42,7 @@ import {
   makeScallopWithdraw,
 } from './tools/scallop'
 import { makeSuiSend } from './tools/send'
+import { makeStake, makeUnstake } from './tools/stake'
 import { makeSwap } from './tools/swap'
 import { makeWalrusStore } from './tools/walrus'
 import type { OnchainRuntimeContext } from './types'
@@ -88,6 +99,12 @@ const plugin: NativePlugin = {
     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)
+
+    // Native staking (delegate SUI to a validator; min 1 SUI).
+    ctx.registerTool(makeStake(onchain) as ToolDef)
+    ctx.registerTool(makeUnstake(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/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,25 @@ 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 +139,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 +204,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/scallop.ts

@@ -12,6 +12,7 @@
 import { Scallop } from '@scallop-io/sui-scallop-sdk'
 import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
+import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
@@ -138,6 +139,10 @@ async function runScallopWrite(
   const amountMist = suiToMist(amount)
   if (amountMist === undefined || amountMist <= 0n)
     return { ok: false, error: `invalid amount "${amount}"` }
+  if (kind === 'supply') {
+    const tooSmall = checkMinimum('supply', amountMist)
+    if (tooSmall) return { ok: false, error: tooSmall }
+  }
 
   // Policy gate (deterministic). Supplying moves funds out; withdrawing back in.
   if (ctx.policy && kind === 'supply') {

package/src/tools/send.ts

@@ -11,6 +11,7 @@
 import { Transaction } from '@mysten/sui/transactions'
 import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
+import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
@@ -40,6 +41,8 @@ export function makeSuiSend(ctx: OnchainRuntimeContext): ToolDef<Args> {
         if (amountMist === undefined || amountMist <= 0n) {
           return { ok: false, error: `invalid amount "${args.amount}"` }
         }
+        const tooSmall = checkMinimum('transfer', amountMist)
+        if (tooSmall) return { ok: false, error: tooSmall }
 
         // 1. Policy gate (deterministic) — block before simulate/execute.
         if (ctx.policy) {

package/src/tools/stake.ts

@@ -0,0 +1,203 @@
+/**
+ * Sui native staking — delegate SUI to a validator and unstake.
+ *
+ *   sui.stake   → 0x3::sui_system::request_add_stake  (min 1 SUI, hard on-chain)
+ *   sui.unstake → 0x3::sui_system::request_withdraw_stake
+ *
+ * Same guarded pipeline as the other write tools: minimum-amount guard →
+ * deterministic policy → dry-run simulate → execute → on-chain effects check.
+ * Sui native staking rejects anything below 1 SUI, so a too-small amount returns
+ * a clear "amount too small" error BEFORE any transaction is built.
+ */
+
+import { Transaction } from '@mysten/sui/transactions'
+import type { ToolDef } from 'lyra-core'
+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 SUI_SYSTEM_STATE = '0x5'
+const STAKED_SUI_TYPE = '0x3::staking_pool::StakedSui'
+
+/** Resolve a validator: match `want` by address/name, else pick a large active one. */
+async function resolveValidator(
+  client: OnchainRuntimeContext['client'],
+  want?: string,
+): Promise<{ address: string; name: string } | null> {
+  const state = await client.getLatestSuiSystemState()
+  // biome-ignore lint/suspicious/noExplicitAny: SuiSystemState validator fields
+  const vals = (state.activeValidators ?? []) as any[]
+  if (vals.length === 0) return null
+  if (want && want.trim()) {
+    const w = want.trim().toLowerCase()
+    const m = vals.find(
+      v => String(v.suiAddress).toLowerCase() === w || String(v.name ?? '').toLowerCase() === w,
+    )
+    if (m) return { address: m.suiAddress, name: m.name ?? '' }
+    // A raw 0x address the user gave is honored even if not in the top set.
+    if (w.startsWith('0x')) return { address: want.trim(), name: '' }
+    return null
+  }
+  // Default: the validator with the most voting power (a large, reliable one).
+  const best = vals.reduce((a, b) => (Number(b.votingPower) > Number(a.votingPower) ? b : a))
+  return { address: best.suiAddress, name: best.name ?? '' }
+}
+
+const StakeSchema = z.object({
+  amount: z.string().min(1).describe('Amount of SUI to stake (minimum 1 SUI).'),
+  validator: z
+    .string()
+    .optional()
+    .describe('Validator address (0x…) or name. Optional — defaults to a large active validator.'),
+})
+type StakeArgs = z.infer<typeof StakeSchema>
+
+export function makeStake(ctx: OnchainRuntimeContext): ToolDef<StakeArgs> {
+  return {
+    name: 'sui.stake',
+    description:
+      'Stake SUI to a validator (Sui native staking) to earn staking rewards. Minimum 1 SUI (enforced by the network). Policy-checked → simulated → executed; returns a StakedSui object.',
+    searchHint: 'stake staking delegate validator earn rewards yield sui native',
+    schema: StakeSchema,
+    handler: async args => {
+      try {
+        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 validator = await resolveValidator(ctx.client, args.validator)
+        if (!validator) return { ok: false, error: 'no active validator found to stake with' }
+
+        const tx = new Transaction()
+        const [coin] = tx.splitCoins(tx.gas, [amountMist])
+        tx.moveCall({
+          target: '0x3::sui_system::request_add_stake',
+          arguments: [tx.object(SUI_SYSTEM_STATE), coin, tx.pure.address(validator.address)],
+        })
+
+        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, showObjectChanges: 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 })
+        const staked = res.objectChanges?.find(
+          c =>
+            c.type === 'created' &&
+            String((c as { objectType?: string }).objectType).includes('staking_pool::StakedSui'),
+        ) as { objectId?: string } | undefined
+
+        return {
+          ok: true,
+          data: {
+            protocol: 'sui-staking',
+            action: 'stake',
+            amountSui: args.amount,
+            validator: validator.address,
+            validatorName: validator.name || undefined,
+            digest: res.digest,
+            stakedSuiId: staked?.objectId ?? null,
+            status: 'success',
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}
+
+const UnstakeSchema = z.object({
+  stakedSuiId: z
+    .string()
+    .optional()
+    .describe('StakedSui object id to withdraw. Optional — defaults to the first staked position.'),
+})
+type UnstakeArgs = z.infer<typeof UnstakeSchema>
+
+export function makeUnstake(ctx: OnchainRuntimeContext): ToolDef<UnstakeArgs> {
+  return {
+    name: 'sui.unstake',
+    description:
+      'Withdraw staked SUI (unstake) from a validator, returning principal + earned rewards. Uses a specific StakedSui object id, or the first staked position if omitted.',
+    searchHint: 'unstake withdraw staking redeem claim rewards validator',
+    schema: UnstakeSchema,
+    handler: async args => {
+      try {
+        let stakedId = args.stakedSuiId?.trim()
+        if (!stakedId) {
+          const owned = await ctx.client.getOwnedObjects({
+            owner: ctx.agentAddress,
+            filter: { StructType: STAKED_SUI_TYPE },
+          })
+          stakedId = owned.data[0]?.data?.objectId
+          if (!stakedId) return { ok: false, error: 'no staked SUI position found to unstake' }
+        }
+
+        if (ctx.policy) {
+          const verdict = evaluatePolicy(
+            { kind: 'transfer', coinType: SUI_TYPE, amountMist: 0n, protocol: 'stake' },
+            ctx.policy,
+          )
+          if (!verdict.allowed) {
+            return { ok: false, error: `policy blocked: ${verdict.violations.join('; ')}` }
+          }
+        }
+
+        const tx = new Transaction()
+        tx.moveCall({
+          target: '0x3::sui_system::request_withdraw_stake',
+          arguments: [tx.object(SUI_SYSTEM_STATE), tx.object(stakedId)],
+        })
+
+        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: 'sui-staking',
+            action: 'unstake',
+            stakedSuiId: stakedId,
+            digest: res.digest,
+            status: 'success',
+          },
+        }
+      } catch (e) {
+        return { ok: false, error: (e as Error).message.slice(0, 240) }
+      }
+    },
+  }
+}

package/src/tools/swap.ts

@@ -13,6 +13,7 @@ import { MetaAg } from '@7kprotocol/sdk-ts'
 import { Transaction, coinWithBalance } from '@mysten/sui/transactions'
 import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
+import { checkMinimum } from '../minimums'
 import { evaluatePolicy } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
@@ -63,6 +64,11 @@ export function makeSwap(ctx: OnchainRuntimeContext): ToolDef<Args> {
         if (from.type === to.type) return { ok: false, error: 'from and to are the same coin' }
         const amountIn = BigInt(Math.round(Number(args.amount) * 10 ** from.decimals))
         if (amountIn <= 0n) return { ok: false, error: `invalid amount "${args.amount}"` }
+        // Minimum only bounds SUI-denominated input (amountIn is then in MIST).
+        if (from.type === SUI_TYPE) {
+          const tooSmall = checkMinimum('swap', amountIn)
+          if (tooSmall) return { ok: false, error: tooSmall }
+        }
 
         // Policy gate. The MIST per-tx cap is SUI-denominated, so it only bounds
         // SUI-input swaps; the slippage/protocol/expiry checks always apply.