lyra-plugin-onchain 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-plugin-onchain",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "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/client.ts

@@ -11,14 +11,23 @@ import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
 
 export type SuiNetwork = 'testnet' | 'mainnet'
 
-/** Canonical fullnode JSON-RPC URL for a network. */
+/**
+ * Fullnode JSON-RPC URL for a network. `LYRA_RPC_URL` overrides the default
+ * public endpoint — recommended in production: the public `fullnode.mainnet.
+ * sui.io` is load-balanced across replicas at different checkpoint heights, so
+ * a freshly-created object (e.g. a just-opened lending obligation) can flicker
+ * in and out between calls. A single dedicated node gives read-your-writes
+ * consistency. The override applies to mainnet only (testnet keeps its default).
+ */
 export function suiRpcUrl(network: SuiNetwork): string {
+  const override = process.env.LYRA_RPC_URL?.trim()
+  if (network === 'mainnet' && override) return override
   return getFullnodeUrl(network)
 }
 
-/** A Sui JSON-RPC client for the given network. */
+/** A Sui JSON-RPC client for the given network (honours `LYRA_RPC_URL`). */
 export function makeSuiClient(network: SuiNetwork): SuiClient {
-  return new SuiClient({ url: getFullnodeUrl(network) })
+  return new SuiClient({ url: suiRpcUrl(network) })
 }
 
 /**

package/src/index.ts

@@ -37,10 +37,8 @@ import {
 import { makePolicyCreate, makePolicyShow } from './tools/policy'
 import { makeProtocolsList } from './tools/protocols'
 import {
-  makeScallopBorrow,
   makeScallopMarkets,
   makeScallopPosition,
-  makeScallopRepay,
   makeScallopSupply,
   makeScallopWithdraw,
 } from './tools/scallop'
@@ -105,8 +103,6 @@ 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)

package/src/protocols.ts

@@ -51,16 +51,9 @@ export const PROTOCOLS: ProtocolCapability[] = [
     category: 'lending',
     read: true,
     execute: true,
-    tools: [
-      'scallop.markets',
-      'scallop.position',
-      'scallop.supply',
-      'scallop.withdraw',
-      'scallop.borrow',
-      'scallop.repay',
-    ],
+    tools: ['scallop.markets', 'scallop.position', 'scallop.supply', 'scallop.withdraw'],
     llamaProjects: ['scallop-lending', 'scallop'],
-    note: 'full supply / withdraw / borrow / repay',
+    note: 'supply / withdraw lending yield (borrow/repay via NAVI or Suilend)',
   },
   {
     id: 'navi',

package/src/tools/scallop.ts

@@ -129,32 +129,30 @@ const AmountSchema = z.object({
 })
 type AmountArgs = z.infer<typeof AmountSchema>
 
+// Scallop redeems a MARKET-COIN amount on withdraw (not underlying SUI). We
+// find the agent's SUI market coin by type pattern (robust to package upgrades).
+const MARKET_COIN_SUI_RE = /::reserve::MarketCoin<0x0*2::sui::SUI>$/
+
 async function runScallopWrite(
   ctx: OnchainRuntimeContext,
   amount: string,
-  kind: 'supply' | 'withdraw' | 'borrow' | 'repay',
+  kind: 'supply' | 'withdraw',
 ): 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 pulls the agent's own funds).
-  const minAction = kind === 'borrow' ? 'borrow' : kind === 'withdraw' ? null : 'supply'
-  if (minAction) {
-    const tooSmall = checkMinimum(minAction, amountMist)
+  // Minimum guard on supply (withdraw pulls the agent's own funds back).
+  if (kind === 'supply') {
+    const tooSmall = checkMinimum('supply', amountMist)
     if (tooSmall) return { ok: false, error: tooSmall }
   }
 
-  // Policy gate on value-moving actions (borrow creates debt + hands out funds).
-  if (ctx.policy && kind !== 'withdraw') {
+  // Policy gate on the value-moving supply.
+  if (ctx.policy && kind === 'supply') {
     const verdict = evaluatePolicy(
-      {
-        kind: 'transfer',
-        coinType: SUI_TYPE,
-        amountMist,
-        protocol: kind === 'borrow' ? 'borrow' : 'scallop',
-      },
+      { kind: 'transfer', coinType: SUI_TYPE, amountMist, protocol: 'scallop' },
       ctx.policy,
     )
     if (!verdict.allowed)
@@ -166,15 +164,34 @@ async function runScallopWrite(
     const builder = await sdk.createScallopBuilder()
     const tx = builder.createTxBlock()
     tx.setSender(ctx.agentAddress)
-    // *Quick helpers auto-select the user's coins/obligation. supply/withdraw and
-    // borrow return a coin to hand back; repay consumes coins. depositQuick's 3rd
-    // arg returnSCoin=false keeps the old market-coin standard (withdrawQuick
-    // redeems it; the new sCoin standard → "No valid coins").
+    // depositQuick's 3rd arg returnSCoin=false keeps the old market-coin standard.
     let out: unknown
-    if (kind === 'supply') out = await tx.depositQuick(Number(amountMist), 'sui', false)
-    else if (kind === 'withdraw') out = await tx.withdrawQuick(Number(amountMist), 'sui')
-    else if (kind === 'borrow') out = await tx.borrowQuick(Number(amountMist), 'sui')
-    else await tx.repayQuick(Number(amountMist), 'sui')
+    if (kind === 'supply') {
+      out = await tx.depositQuick(Number(amountMist), 'sui', false)
+    } else {
+      // withdrawQuick redeems a MARKET-COIN amount, not underlying SUI. Convert
+      // the requested SUI to market coins at the position's rate and clamp to the
+      // held balance, so a full/over-withdraw cleanly redeems everything.
+      const [balances, q] = await Promise.all([
+        ctx.client.getAllBalances({ owner: ctx.agentAddress }),
+        sdk.createScallopQuery().then(async query => {
+          await query.init()
+          return query
+        }),
+      ])
+      const mc = balances.find(b => MARKET_COIN_SUI_RE.test(b.coinType))
+      const heldMc = BigInt(mc?.totalBalance ?? '0')
+      if (heldMc <= 0n) return { ok: false, error: 'no Scallop SUI position to withdraw' }
+      const port = (await q.getUserPortfolio({ walletAddress: ctx.agentAddress })) as {
+        lendings?: Array<{ coinName?: string; suppliedCoin?: number }>
+      }
+      const supplied = (port.lendings ?? []).find(l => l.coinName === 'sui')?.suppliedCoin ?? 0
+      const suppliedMist = BigInt(Math.floor(supplied * 1e9))
+      // redeem = requested/rate, where rate = supplied/heldMc; clamp to heldMc.
+      let redeemMc = suppliedMist > 0n ? (amountMist * heldMc) / suppliedMist : heldMc
+      if (redeemMc > heldMc || redeemMc <= 0n) redeemMc = heldMc
+      out = await tx.withdrawQuick(Number(redeemMc), 'sui')
+    }
     if (out) tx.transferObjects([out as never], ctx.agentAddress)
     const transaction = tx.txBlock
 
@@ -229,23 +246,8 @@ export function makeScallopWithdraw(ctx: OnchainRuntimeContext): ToolDef<AmountA
   }
 }
 
-export function makeScallopBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
-  return {
-    name: 'scallop.borrow',
-    description:
-      'Borrow SUI from Scallop against supplied collateral. Requires an existing supply position with enough health; the pre-flight simulation fails cleanly if under-collateralized. Policy-checked, simulated, then executed.',
-    searchHint: 'scallop borrow loan leverage debt against collateral sui',
-    schema: AmountSchema,
-    handler: async args => runScallopWrite(ctx, args.amount, 'borrow'),
-  }
-}
-
-export function makeScallopRepay(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
-  return {
-    name: 'scallop.repay',
-    description: 'Repay borrowed SUI debt on Scallop. Simulated, then executed.',
-    searchHint: 'scallop repay pay back debt loan close sui',
-    schema: AmountSchema,
-    handler: async args => runScallopWrite(ctx, args.amount, 'repay'),
-  }
-}
+// NOTE: Scallop borrow/repay require opening a Scallop obligation + posting
+// collateral (a separate flow from lending deposits — borrowQuick alone aborts
+// "No obligation found"). Until that flow is wired, borrowing routes through the
+// verified NAVI/Suilend adapters instead, so we don't ship a borrow tool here
+// that can't execute.

package/src/tools/suilend.ts

@@ -57,19 +57,31 @@ function isSuiType(t: string): boolean {
   return t === SUI_TYPE || t === SUI_LONG
 }
 
-/** The agent's obligation cap + id, or null if it has no Suilend position yet. */
+/** The agent's obligation cap + id, or null if it has no Suilend position yet.
+ *  Retries: getObligationOwnerCaps reads owned objects + their BCS, which some
+ *  fullnode replicas serve inconsistently right after a write ("invalid data
+ *  type" / stale owned-object index) — a short retry rides out that lag. */
 async function findObligation(
   ctx: OnchainRuntimeContext,
 ): Promise<{ capId: string; obligationId: string } | null> {
-  const caps = await SuilendClient.getObligationOwnerCaps(
-    ctx.agentAddress,
-    [LENDING_MARKET_TYPE],
-    ctx.client as never,
-  )
-  if (!caps.length) return null
-  const c = caps[0] as { id: unknown; obligationId: string | { id: string } }
-  const obligationId = typeof c.obligationId === 'string' ? c.obligationId : c.obligationId.id
-  return { capId: capObjectId(c), obligationId }
+  let lastErr: unknown
+  for (let attempt = 0; attempt < 4; attempt++) {
+    try {
+      const caps = await SuilendClient.getObligationOwnerCaps(
+        ctx.agentAddress,
+        [LENDING_MARKET_TYPE],
+        ctx.client as never,
+      )
+      if (!caps.length) return null
+      const c = caps[0] as { id: unknown; obligationId: string | { id: string } }
+      const obligationId = typeof c.obligationId === 'string' ? c.obligationId : c.obligationId.id
+      return { capId: capObjectId(c), obligationId }
+    } catch (e) {
+      lastErr = e
+      await new Promise(r => setTimeout(r, 1200))
+    }
+  }
+  throw lastErr
 }
 
 // --- suilend.supply --------------------------------------------------------
@@ -79,6 +91,43 @@ const AmountSchema = z.object({
 })
 type AmountArgs = z.infer<typeof AmountSchema>
 
+// Borrowable/repayable assets. Suilend (like most money markets) forbids
+// borrowing the SAME asset you post as collateral (obligation::borrow abort 8),
+// so the canonical flow is "supply SUI → borrow a stablecoin". USDC is the
+// default; SUI is available for the reverse (supply a stable, borrow SUI).
+const USDC_TYPE = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC'
+type CoinInfo = { type: string; decimals: number; minBase: bigint; label: string }
+const BORROW_COINS: Record<'usdc' | 'sui', CoinInfo> = {
+  usdc: { type: USDC_TYPE, decimals: 6, minBase: 100_000n, label: 'USDC' }, // 0.1 USDC
+  sui: { type: SUI_TYPE, decimals: 9, minBase: 10_000_000n, label: 'SUI' }, // 0.01 SUI
+}
+
+/** Parse a decimal amount into base units for a given decimals count. */
+function toBaseUnits(amount: string, decimals: number): bigint | undefined {
+  const a = amount.trim()
+  if (!/^\d+(\.\d+)?$/.test(a)) return undefined
+  const dot = a.indexOf('.')
+  const whole = dot === -1 ? a : a.slice(0, dot)
+  const frac = dot === -1 ? '' : a.slice(dot + 1)
+  const fracPadded = (frac + '0'.repeat(decimals)).slice(0, decimals)
+  try {
+    return BigInt(whole || '0') * 10n ** BigInt(decimals) + BigInt(fracPadded || '0')
+  } catch {
+    return undefined
+  }
+}
+
+const BorrowSchema = z.object({
+  amount: z.string().min(1).describe('Amount to borrow/repay, e.g. "5".'),
+  coin: z
+    .enum(['usdc', 'sui'])
+    .optional()
+    .describe(
+      'Asset to borrow/repay (default "usdc"). Suilend disallows borrowing the same asset you supply as collateral, so borrowing USDC against SUI collateral is the canonical flow.',
+    ),
+})
+type BorrowArgs = z.infer<typeof BorrowSchema>
+
 export function makeSuilendSupply(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
   return {
     name: 'suilend.supply',
@@ -217,24 +266,25 @@ export function makeSuilendWithdraw(ctx: OnchainRuntimeContext): ToolDef<AmountA
 
 // --- suilend.borrow --------------------------------------------------------
 
-export function makeSuilendBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
+export function makeSuilendBorrow(ctx: OnchainRuntimeContext): ToolDef<BorrowArgs> {
   return {
     name: 'suilend.borrow',
     description:
-      'Borrow SUI from Suilend against supplied collateral (amount in underlying SUI). Requires an existing obligation with enough health; the pre-flight simulation fails cleanly if under-collateralized. Policy-checked, simulated, then executed.',
-    searchHint: 'suilend borrow loan leverage debt against collateral sui money market',
-    schema: AmountSchema,
+      'Borrow an asset from Suilend against supplied collateral. Default borrows USDC against SUI collateral (Suilend disallows same-asset borrows). Requires an existing obligation with enough health; the pre-flight simulation fails cleanly if under-collateralized. Policy-checked, simulated, then executed.',
+    searchHint: 'suilend borrow loan leverage debt against collateral usdc stablecoin money market',
+    schema: BorrowSchema,
     handler: async args => {
       const err = ensureMainnet(ctx)
       if (err) return { ok: false, error: err }
-      const amountMist = suiToMist(args.amount)
-      if (amountMist === undefined || amountMist <= 0n)
+      const coin = BORROW_COINS[args.coin ?? 'usdc']
+      const amountBase = toBaseUnits(args.amount, coin.decimals)
+      if (amountBase === undefined || amountBase <= 0n)
         return { ok: false, error: `invalid amount "${args.amount}"` }
-      const tooSmall = checkMinimum('borrow', amountMist)
-      if (tooSmall) return { ok: false, error: tooSmall }
+      if (amountBase < coin.minBase)
+        return { ok: false, error: `amount too small: below the minimum ${coin.label} borrow` }
       if (ctx.policy) {
         const verdict = evaluatePolicy(
-          { kind: 'transfer', coinType: SUI_TYPE, amountMist, protocol: 'borrow' },
+          { kind: 'transfer', coinType: coin.type, amountMist: amountBase, protocol: 'borrow' },
           ctx.policy,
         )
         if (!verdict.allowed)
@@ -252,8 +302,8 @@ export function makeSuilendBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArg
           ctx.agentAddress,
           obligation.capId,
           obligation.obligationId,
-          SUI_TYPE,
-          amountMist.toString(),
+          coin.type,
+          amountBase.toString(),
           tx as never,
         )
         const sim = await simulate(ctx.client, tx, ctx.agentAddress)
@@ -274,7 +324,8 @@ export function makeSuilendBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArg
           data: {
             protocol: 'suilend',
             action: 'borrow',
-            amountSui: args.amount,
+            amount: args.amount,
+            coin: coin.label,
             digest: res.digest,
             policyEnforced: ctx.policy != null,
           },
@@ -288,22 +339,23 @@ export function makeSuilendBorrow(ctx: OnchainRuntimeContext): ToolDef<AmountArg
 
 // --- suilend.repay ---------------------------------------------------------
 
-export function makeSuilendRepay(ctx: OnchainRuntimeContext): ToolDef<AmountArgs> {
+export function makeSuilendRepay(ctx: OnchainRuntimeContext): ToolDef<BorrowArgs> {
   return {
     name: 'suilend.repay',
     description:
-      'Repay borrowed SUI debt on Suilend (amount in underlying SUI). Simulated, then executed.',
-    searchHint: 'suilend repay pay back debt loan close sui money market',
-    schema: AmountSchema,
+      'Repay borrowed debt on Suilend (default USDC; pass coin "sui" to repay a SUI loan). Simulated, then executed.',
+    searchHint: 'suilend repay pay back debt loan close usdc stablecoin sui money market',
+    schema: BorrowSchema,
     handler: async args => {
       const err = ensureMainnet(ctx)
       if (err) return { ok: false, error: err }
-      const amountMist = suiToMist(args.amount)
-      if (amountMist === undefined || amountMist <= 0n)
+      const coin = BORROW_COINS[args.coin ?? 'usdc']
+      const amountBase = toBaseUnits(args.amount, coin.decimals)
+      if (amountBase === undefined || amountBase <= 0n)
         return { ok: false, error: `invalid amount "${args.amount}"` }
       if (ctx.policy) {
         const verdict = evaluatePolicy(
-          { kind: 'transfer', coinType: SUI_TYPE, amountMist, protocol: 'suilend' },
+          { kind: 'transfer', coinType: coin.type, amountMist: amountBase, protocol: 'suilend' },
           ctx.policy,
         )
         if (!verdict.allowed)
@@ -318,8 +370,8 @@ export function makeSuilendRepay(ctx: OnchainRuntimeContext): ToolDef<AmountArgs
         await suilend.repayIntoObligation(
           ctx.agentAddress,
           obligation.obligationId,
-          SUI_TYPE,
-          amountMist.toString(),
+          coin.type,
+          amountBase.toString(),
           tx as never,
         )
         const sim = await simulate(ctx.client, tx, ctx.agentAddress)
@@ -340,7 +392,8 @@ export function makeSuilendRepay(ctx: OnchainRuntimeContext): ToolDef<AmountArgs
           data: {
             protocol: 'suilend',
             action: 'repay',
-            amountSui: args.amount,
+            amount: args.amount,
+            coin: coin.label,
             digest: res.digest,
           },
         }

package/src/tools/tools.test.ts

@@ -15,7 +15,7 @@ import type { PluginContext, ToolDef } from 'lyra-core'
 import plugin from '../index'
 import type { OnchainRuntimeContext } from '../types'
 import { makeVoloStake } from './liquid-stake'
-import { makeScallopBorrow, makeScallopRepay } from './scallop'
+import { makeNaviBorrow, makeNaviRepay } from './navi'
 import { makeSuilendBorrow, makeSuilendSupply } from './suilend'
 
 // A context whose network/amount guards resolve before any client access.
@@ -56,8 +56,6 @@ describe('onchain plugin registration', () => {
       // lending: the three biggest Sui money markets, full CRUD
       'scallop.supply',
       'scallop.withdraw',
-      'scallop.borrow',
-      'scallop.repay',
       'navi.supply',
       'navi.borrow',
       'navi.repay',
@@ -112,8 +110,8 @@ describe('write-tool guards (fail before network)', () => {
     if (!res.ok) expect(res.error).toContain('amount too small')
   })
 
-  test('scallop.borrow rejects a dust amount', async () => {
-    const res = await makeScallopBorrow(stubCtx()).handler({ amount: '0.001' })
+  test('navi.borrow rejects a dust amount', async () => {
+    const res = await makeNaviBorrow(stubCtx()).handler({ amount: '0.001' })
     expect(res.ok).toBe(false)
     if (!res.ok) expect(res.error).toContain('amount too small')
   })
@@ -134,9 +132,9 @@ describe('write-tool guards (fail before network)', () => {
     if (!stake.ok) expect(stake.error).toContain('mainnet only')
   })
 
-  test('scallop.repay is a registered, well-formed tool', () => {
-    const tool = makeScallopRepay(stubCtx())
-    expect(tool.name).toBe('scallop.repay')
+  test('navi.repay is a registered, well-formed tool', () => {
+    const tool = makeNaviRepay(stubCtx())
+    expect(tool.name).toBe('navi.repay')
     expect(typeof tool.handler).toBe('function')
   })
 })