lyra-plugin-onchain 0.1.8 → 0.1.10

package/src/policy.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  type SuiPolicy,
-  type SuiPolicyAction,
-  evaluatePolicy,
-  normalizeCoinType,
-  policyFromEnv,
-  suiToMist,
-} from './policy'
-
-const ONE_SUI = 1_000_000_000n // 1 SUI in MIST
-const SUI = '0x2::sui::SUI'
-
-const send = (over: Partial<SuiPolicyAction> = {}): SuiPolicyAction => ({
-  kind: 'transfer',
-  coinType: SUI,
-  amountMist: ONE_SUI,
-  to: '0x1111111111111111111111111111111111111111111111111111111111111111',
-  protocol: 'transfer',
-  ...over,
-})
-
-describe('evaluatePolicy', () => {
-  it('allows a compliant native transfer', () => {
-    const v = evaluatePolicy(send(), { maxMistPerTx: 2n * ONE_SUI })
-    expect(v.allowed).toBe(true)
-    expect(v.violations).toHaveLength(0)
-    expect(v.requiresApproval).toBe(false)
-  })
-
-  it('blocks a transfer over the per-tx cap', () => {
-    const v = evaluatePolicy(send({ amountMist: 5n * ONE_SUI }), { maxMistPerTx: 2n * ONE_SUI })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('exceeds per-tx cap')
-  })
-
-  it('blocks a recipient not in the allowlist', () => {
-    const v = evaluatePolicy(send({ to: '0x2222' }), { recipientAllowlist: ['0x1111'] })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the recipient allowlist')
-  })
-
-  it('allows an allowlisted recipient case-insensitively', () => {
-    const v = evaluatePolicy(send({ to: '0xABCD' }), { recipientAllowlist: ['0xabcd'] })
-    expect(v.allowed).toBe(true)
-  })
-
-  it('blocks a coin not in the coin allowlist', () => {
-    const v = evaluatePolicy(send({ coinType: '0xdead::x::X' }), { coinAllowlist: [SUI] })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the coin allowlist')
-  })
-
-  it('allows SUI by short or padded form against an allowlist', () => {
-    const padded = `0x${'0'.repeat(63)}2::sui::SUI`
-    expect(evaluatePolicy(send({ coinType: padded }), { coinAllowlist: [SUI] }).allowed).toBe(true)
-    expect(evaluatePolicy(send({ coinType: 'native' }), { coinAllowlist: [SUI] }).allowed).toBe(
-      true,
-    )
-  })
-
-  it('blocks a swap whose slippage exceeds the cap', () => {
-    const v = evaluatePolicy(
-      { kind: 'swap', coinType: SUI, amountMist: ONE_SUI, slippageBps: 300 },
-      { maxSlippageBps: 100 },
-    )
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('slippage')
-  })
-
-  it('blocks a protocol not in the protocol allowlist', () => {
-    const v = evaluatePolicy(send({ protocol: 'cetus' }), {
-      protocolAllowlist: ['transfer', 'deepbook'],
-    })
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('not in the protocol allowlist')
-  })
-
-  it('blocks everything under a read-only policy', () => {
-    expect(evaluatePolicy(send(), { readOnly: true }).allowed).toBe(false)
-    expect(evaluatePolicy(send(), { autonomy: 'readonly' }).allowed).toBe(false)
-  })
-
-  it('blocks when the policy has expired', () => {
-    const v = evaluatePolicy(send(), { expiryMs: 1_000 }, 2_000)
-    expect(v.allowed).toBe(false)
-    expect(v.violations[0]).toContain('expired')
-  })
-
-  it('allows before the policy expires', () => {
-    expect(evaluatePolicy(send(), { expiryMs: 5_000 }, 2_000).allowed).toBe(true)
-  })
-
-  it('requires approval in the confirm tier', () => {
-    const v = evaluatePolicy(send(), { autonomy: 'confirm' })
-    expect(v.allowed).toBe(true)
-    expect(v.requiresApproval).toBe(true)
-  })
-
-  it('escalates to approval when a spend exceeds the auto ceiling', () => {
-    const policy: SuiPolicy = { autonomy: 'auto', autoMaxMistPerTx: ONE_SUI / 10n }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI / 100n }), policy).requiresApproval).toBe(
-      false,
-    )
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).requiresApproval).toBe(true)
-  })
-})
-
-describe('coin allowlist — adversarial', () => {
-  const A = '0xaaa::coin::A'
-  const B = '0xbbb::coin::B'
-  const policy: SuiPolicy = { coinAllowlist: [A] }
-
-  it('blocks a swap whose OUTPUT coin is not allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: A, toCoinType: B, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(false)
-    expect(v.violations.some(s => /output coin/.test(s))).toBe(true)
-  })
-
-  it('allows a swap when both legs are allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: A, toCoinType: A, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(true)
-  })
-
-  it('still blocks a swap whose INPUT coin is not allowlisted', () => {
-    const v = evaluatePolicy({ kind: 'swap', coinType: B, toCoinType: A, amountMist: 1n }, policy)
-    expect(v.allowed).toBe(false)
-  })
-})
-
-describe('amount-cap boundaries', () => {
-  it('allows exactly at the cap, blocks one MIST over', () => {
-    const policy: SuiPolicy = { maxMistPerTx: ONE_SUI }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).allowed).toBe(true)
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI + 1n }), policy).allowed).toBe(false)
-  })
-
-  it('auto tier: no approval exactly at the auto ceiling, approval one MIST over', () => {
-    const policy: SuiPolicy = { autoMaxMistPerTx: ONE_SUI }
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI }), policy).requiresApproval).toBe(false)
-    expect(evaluatePolicy(send({ amountMist: ONE_SUI + 1n }), policy).requiresApproval).toBe(true)
-  })
-})
-
-describe('suiToMist + normalizeCoinType', () => {
-  it('converts decimal SUI to MIST', () => {
-    expect(suiToMist('1')).toBe(ONE_SUI)
-    expect(suiToMist('0.1')).toBe(ONE_SUI / 10n)
-    expect(suiToMist('1.5')).toBe(1_500_000_000n)
-    expect(suiToMist('')).toBeUndefined()
-    expect(suiToMist('-1')).toBeUndefined()
-  })
-
-  it('canonicalizes SUI forms and aliases', () => {
-    expect(normalizeCoinType('SUI')).toBe('0x2::sui::sui')
-    expect(normalizeCoinType('native')).toBe('0x2::sui::sui')
-    expect(normalizeCoinType(`0x${'0'.repeat(63)}2::sui::SUI`)).toBe('0x2::sui::sui')
-  })
-})
-
-describe('policyFromEnv', () => {
-  it('returns undefined when no policy env is set', () => {
-    expect(policyFromEnv({})).toBeUndefined()
-  })
-
-  it('parses caps, slippage, tier, allowlists and expiry', () => {
-    const p = policyFromEnv(
-      {
-        LYRA_POLICY_MAX_PER_TX_SUI: '1.0',
-        LYRA_POLICY_AUTO_MAX_SUI: '0.1',
-        LYRA_POLICY_MAX_SLIPPAGE_BPS: '100',
-        LYRA_POLICY_AUTONOMY: 'auto',
-        LYRA_POLICY_ALLOWED_PROTOCOLS: 'transfer, deepbook, walrus',
-        LYRA_POLICY_ALLOWED_COINS: '0x2::sui::SUI',
-        LYRA_POLICY_EXPIRY_MINUTES: '60',
-      },
-      1_000_000,
-    )
-    expect(p?.maxMistPerTx).toBe(ONE_SUI)
-    expect(p?.autoMaxMistPerTx).toBe(ONE_SUI / 10n)
-    expect(p?.maxSlippageBps).toBe(100)
-    expect(p?.autonomy).toBe('auto')
-    expect(p?.protocolAllowlist).toEqual(['transfer', 'deepbook', 'walrus'])
-    expect(p?.coinAllowlist).toEqual(['0x2::sui::SUI'])
-    expect(p?.expiryMs).toBe(1_000_000 + 60 * 60_000)
-  })
-})

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

@@ -1,111 +0,0 @@
-/**
- * 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)
-})

package/src/tools/tools.test.ts

@@ -1,142 +0,0 @@
-/**
- * Unit coverage for the DeFi tool surface: (1) the plugin registers every
- * value-moving adapter, and (2) each new write tool runs its guard checks
- * (mainnet-only, valid amount, minimum size) BEFORE it ever touches the
- * network — so a dust/invalid/testnet request fails fast and deterministically,
- * never a false success.
- *
- * These tests deliberately use a bare stub context: the guard branches return
- * before any `client`/`keypair` access, so no RPC is needed. Live end-to-end
- * PTB simulation lives in `onchain.integration.test.ts` (gated on a real key).
- */
-
-import { describe, expect, test } from 'bun:test'
-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 { makeSuilendBorrow, makeSuilendSupply } from './suilend'
-
-// A context whose network/amount guards resolve before any client access.
-function stubCtx(network: 'mainnet' | 'testnet' = 'mainnet'): OnchainRuntimeContext {
-  return {
-    network,
-    agentAddress: '0x0000000000000000000000000000000000000000000000000000000000000abc',
-    agentDir: '/tmp/lyra-test',
-    // Accessing either of these would throw — guards must return first.
-    client: new Proxy(
-      {},
-      {
-        get() {
-          throw new Error('network access before guard')
-        },
-      },
-    ) as never,
-    keypair: {} as never,
-  }
-}
-
-describe('onchain plugin registration', () => {
-  test('registers the full DeFi write surface (lending + staking + swap)', () => {
-    const names: string[] = []
-    const ctx = {
-      registerTool: (def: ToolDef) => names.push(def.name),
-      registerListener: () => {},
-      addHook: () => {},
-      network: 'mainnet',
-      agentDir: '/tmp',
-      agentId: 'test',
-      // side-banded onchain runtime the plugin reads off PluginContext
-      onchain: stubCtx(),
-    } as unknown as PluginContext
-    plugin.register(ctx)
-
-    for (const expected of [
-      // lending: the three biggest Sui money markets, full CRUD
-      'scallop.supply',
-      'scallop.withdraw',
-      'scallop.borrow',
-      'scallop.repay',
-      'navi.supply',
-      'navi.borrow',
-      'navi.repay',
-      'suilend.supply',
-      'suilend.withdraw',
-      'suilend.borrow',
-      'suilend.repay',
-      'suilend.position',
-      // staking: native + Volo liquid staking
-      'sui.stake',
-      'sui.unstake',
-      'volo.stake',
-      'volo.unstake',
-      // swap aggregator
-      'swap',
-    ]) {
-      expect(names).toContain(expected)
-    }
-  })
-
-  test('registers nothing without an onchain runtime (safe no-op for loaders)', () => {
-    const names: string[] = []
-    const ctx = {
-      registerTool: (def: ToolDef) => names.push(def.name),
-      registerListener: () => {},
-      addHook: () => {},
-      network: 'mainnet',
-      agentDir: '/tmp',
-      agentId: 'test',
-    } as unknown as PluginContext
-    plugin.register(ctx)
-    expect(names).toHaveLength(0)
-  })
-})
-
-describe('write-tool guards (fail before network)', () => {
-  test('suilend.supply rejects a dust amount below the supply minimum', async () => {
-    const res = await makeSuilendSupply(stubCtx()).handler({ amount: '0.001' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('suilend.borrow rejects a dust amount below the borrow minimum', async () => {
-    const res = await makeSuilendBorrow(stubCtx()).handler({ amount: '0.0001' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('volo.stake rejects below the 1 SUI staking minimum', async () => {
-    const res = await makeVoloStake(stubCtx()).handler({ amount: '0.1' })
-    expect(res.ok).toBe(false)
-    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' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('amount too small')
-  })
-
-  test('invalid amount strings are rejected before any network call', async () => {
-    const res = await makeVoloStake(stubCtx()).handler({ amount: 'not-a-number' })
-    expect(res.ok).toBe(false)
-    if (!res.ok) expect(res.error).toContain('invalid amount')
-  })
-
-  test('mainnet-only tools refuse to run on testnet', async () => {
-    const supply = await makeSuilendSupply(stubCtx('testnet')).handler({ amount: '5' })
-    expect(supply.ok).toBe(false)
-    if (!supply.ok) expect(supply.error).toContain('mainnet only')
-
-    const stake = await makeVoloStake(stubCtx('testnet')).handler({ amount: '5' })
-    expect(stake.ok).toBe(false)
-    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')
-    expect(typeof tool.handler).toBe('function')
-  })
-})