lyra-plugin-onchain 0.1.8 → 0.1.10

package/src/tools/suilend.ts

@@ -20,18 +20,22 @@
  */
 
 import { Transaction } from '@mysten/sui/transactions'
-import {
-  LENDING_MARKET_ID,
-  LENDING_MARKET_TYPE,
-  SuilendClient,
-  initializeSuilend,
-} from '@suilend/sdk'
+// Import from @suilend/sdk SUBPATHS, not the package index. The index re-exports
+// strategies.js → @suilend/springsui-sdk, whose ESM does a directory import
+// (`import './lib'`) that Node's ESM resolver rejects — which would break
+// importing this plugin under Node (the Next.js web server; Bun tolerates it).
+// The lending client + initialize subpaths don't pull springsui and load cleanly
+// on both runtimes, so Suilend works on the web AND the CLI.
+import { LENDING_MARKET_ID, LENDING_MARKET_TYPE, SuilendClient } from '@suilend/sdk/client'
+import { initializeSuilend } from '@suilend/sdk/lib/initialize'
 import type { ToolDef } from 'lyra-core'
 import { z } from 'zod'
 import { checkMinimum } from '../minimums'
 import { evaluatePolicy, suiToMist } from '../policy'
+import { PROTOCOL_IDS } from '../protocol-ids'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 // Canonical + long-form SUI coin types (reserve maps may use either).
@@ -57,19 +61,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 +95,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',
@@ -107,7 +160,12 @@ export function makeSuilendSupply(ctx: OnchainRuntimeContext): ToolDef<AmountArg
         const existing = await findObligation(ctx)
         const tx = new Transaction()
         tx.setSender(ctx.agentAddress)
-        const [coin] = tx.splitCoins(tx.gas, [amountMist])
+        // Source the supply from the treasury vault (policy-enforced) when wired.
+        const coin = fundSui(tx, ctx, amountMist, {
+          protocol: PROTOCOL_IDS.suilend,
+          kind: 'supply',
+          memo: 'suilend supply',
+        })
         // The @suilend/sdk@1.1.x SDK carries its own nested @mysten/sui copy, so
         // TS sees a distinct Transaction class — cast at the boundary. The two
         // copies interop at runtime (verified with a live mainnet dry-run).
@@ -217,24 +275,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 +311,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 +333,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 +348,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 +379,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 +401,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/swap.ts

@@ -17,6 +17,7 @@ import { checkMinimum } from '../minimums'
 import { evaluatePolicy } from '../policy'
 import { simulate } from '../simulate'
 import type { OnchainRuntimeContext } from '../types'
+import { fundSui } from '../vault-fund'
 
 const SUI_TYPE = '0x2::sui::SUI'
 
@@ -119,9 +120,16 @@ export function makeSwap(ctx: OnchainRuntimeContext): ToolDef<Args> {
           tx.setSender(me)
           tx.setGasBudget(150_000_000)
           try {
+            // SUI input is sourced from the treasury vault (policy-enforced) when
+            // wired; non-SUI input comes from the agent's own balance (the vault
+            // is SUI-typed). The swapped output goes to the agent.
             const coinIn =
               from.type === SUI_TYPE
-                ? tx.splitCoins(tx.gas, [amountIn])[0]
+                ? fundSui(tx, ctx, amountIn, {
+                    protocol: '0x0',
+                    kind: 'swap',
+                    memo: `swap to ${args.to}`,
+                  })
                 : coinWithBalance({ type: from.type, balance: amountIn })
             const coinOut = await ag.swap({ quote: q, signer: me, tx, coinIn: coinIn as never })
             tx.transferObjects([coinOut as never], me)

package/src/types.ts

@@ -23,6 +23,27 @@ export interface OnchainRuntimeContext {
   packageId?: string
   /** Shared `AgentPolicy` object id. When set, writes compose an on-chain receipt + enforcement. */
   policyObjectId?: string
+  /**
+   * Treasury `Vault<SUI>` object id bound to `policyObjectId`. When set (together
+   * with `policyObjectId` + `packageId`), write tools source their SUI from the
+   * vault via the policy-gated `vault_spend` instead of the agent's gas coin — so
+   * the vault is the single fund source and every deployment is enforced on-chain.
+   * When unset, tools fall back to the agent's own SUI (single-key mode).
+   */
+  vaultId?: string
+  /**
+   * The vault/policy owner address. Audit `ActionReceipt`s from `vault_spend` are
+   * sent here (falls back to the agent when unset). The owner also receives any
+   * funds swept back to the treasury.
+   */
+  ownerAddress?: string
+  /**
+   * Snapshot of the vault's SUI balance (MIST, as a string) at ctx-build time.
+   * A funding heuristic: when the vault can't cover an action, tools fall back to
+   * the agent's own SUI so the action still works (the on-chain `vault_spend` is
+   * the authoritative gate). Absent/`"0"` ⇒ always fall back.
+   */
+  vaultMist?: string
   /** Walrus network for receipt/memory storage (defaults to `network`). */
   walrusNetwork?: SuiNetwork
   agentDir: string

package/src/vault-fund.ts

@@ -0,0 +1,107 @@
+/**
+ * Vault-funded actions. Lyra's treasury `lyra::vault::Vault<SUI>` is the SINGLE
+ * fund source for agent actions: instead of splitting the agent's own gas coin,
+ * a write tool draws SUI from the owner's vault via the policy-gated `vault_spend`
+ * (the agent signs; `enforce_spend` re-checks budget, per-tx cap, coin/protocol
+ * allowlists, expiry, and revoke ON-CHAIN). Idle funds stay in the vault, and the
+ * treasury is topped back up on withdrawal (Option 1: funds cycle vault→protocol→
+ * vault, so the treasury doesn't drain as the agent works).
+ *
+ * All helpers degrade gracefully: with no vault configured in the runtime ctx,
+ * `fundSui` falls back to the agent's gas coin — so single-key mode (e.g. the CLI
+ * with no provisioned vault) keeps working unchanged.
+ */
+
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+import type { OnchainRuntimeContext } from './types'
+
+const SUI_TYPE = '0x2::sui::SUI'
+const CLOCK = '0x6'
+
+/** True when the ctx carries a fully-wired treasury vault (vault + policy + package). */
+export function hasVault(ctx: OnchainRuntimeContext): boolean {
+  return Boolean(ctx.vaultId && ctx.policyObjectId && ctx.packageId)
+}
+
+/**
+ * True when the wired vault can cover `amountMist` (per its balance snapshot).
+ * When false, callers fund from the agent's own SUI so the action still works —
+ * e.g. the user provisioned a vault but funded the agent directly, or the vault
+ * is short for this action. The on-chain `vault_spend` remains the hard gate.
+ */
+export function canFundFromVault(ctx: OnchainRuntimeContext, amountMist: bigint): boolean {
+  if (!hasVault(ctx)) return false
+  return BigInt(ctx.vaultMist ?? '0') >= amountMist
+}
+
+function enc(tx: Transaction, s: string) {
+  return tx.pure.vector('u8', Array.from(new TextEncoder().encode(s)))
+}
+
+export interface FundOpts {
+  /**
+   * Protocol package/registry id checked against the policy's protocol allowlist.
+   * Pass the protocol's package id (e.g. NAVI, Scallop) so an owner-set allowlist
+   * gates it meaningfully; `0x0` when the action isn't protocol-scoped (a plain
+   * transfer). Defaults to `0x0`.
+   */
+  protocol?: string
+  /** Short action kind for the on-chain receipt (e.g. `stake`, `supply`, `swap`). */
+  kind: string
+  /** Human memo for the on-chain receipt. */
+  memo: string
+}
+
+/**
+ * Source `amountMist` of SUI for an in-PTB action. When a vault is wired, draws
+ * from it via `vault_spend` (policy-enforced) and routes the audit `ActionReceipt`
+ * to the owner; otherwise splits the agent's gas coin. Returns the `Coin<SUI>` to
+ * feed into the protocol call in the SAME transaction.
+ */
+export function fundSui(
+  tx: Transaction,
+  ctx: OnchainRuntimeContext,
+  amountMist: bigint,
+  opts: FundOpts,
+): TransactionObjectArgument {
+  if (canFundFromVault(ctx, amountMist)) {
+    const [coin, receipt] = tx.moveCall({
+      target: `${ctx.packageId}::vault::vault_spend`,
+      typeArguments: [SUI_TYPE],
+      arguments: [
+        tx.object(ctx.vaultId as string),
+        tx.object(ctx.policyObjectId as string),
+        tx.pure.u64(amountMist),
+        tx.pure.address(opts.protocol ?? '0x0'),
+        enc(tx, opts.kind),
+        enc(tx, opts.memo),
+        tx.object(CLOCK),
+      ],
+    })
+    // The receipt is an on-chain audit object (key+store); park it with the owner
+    // (or the agent when the owner is unknown) so the PTB has no dangling value.
+    tx.transferObjects([receipt as TransactionObjectArgument], ctx.ownerAddress ?? ctx.agentAddress)
+    return coin as TransactionObjectArgument
+  }
+  const [coin] = tx.splitCoins(tx.gas, [amountMist])
+  return coin as TransactionObjectArgument
+}
+
+/**
+ * Return a `Coin<SUI>` to the treasury vault (Option 1: withdrawals/unstakes cycle
+ * back into the vault instead of accumulating on the agent). No-op-returns `false`
+ * when no vault is wired, so the caller can transfer the coin to the agent instead.
+ */
+export function returnSuiToVault(
+  tx: Transaction,
+  ctx: OnchainRuntimeContext,
+  coin: TransactionObjectArgument,
+): boolean {
+  if (!ctx.vaultId || !ctx.packageId) return false
+  tx.moveCall({
+    target: `${ctx.packageId}::vault::deposit`,
+    typeArguments: [SUI_TYPE],
+    arguments: [tx.object(ctx.vaultId), coin],
+  })
+  return true
+}

package/src/vault.ts

@@ -22,6 +22,70 @@ export interface OwnerVault {
   vaultMist: string
 }
 
+export interface AgentVault {
+  policyId: string
+  vaultId: string
+  owner: string
+  vaultMist: string
+}
+
+/**
+ * Resolve the treasury vault for a delegated `agentAddress` WITHOUT knowing the
+ * owner — the CLI/gateway single-tenant path (the running agent knows only its own
+ * address). Finds the `AgentPolicy` delegating to this agent via `PolicyCreated`
+ * events, then its `Vault` via `VaultOpened`. Returns null when the agent has no
+ * (unrevoked) policy+vault, so the tools fall back to the agent's own SUI.
+ */
+export async function resolveVaultForAgent(
+  agentAddress: string,
+  network: SuiNetwork = 'mainnet',
+): Promise<AgentVault | null> {
+  const client = makeSuiClient(network)
+  const created = await client
+    .queryEvents({
+      query: { MoveEventType: `${ORIGINAL_PKG}::policy::PolicyCreated` },
+      limit: 200,
+      order: 'descending',
+    })
+    .catch(() => null)
+  if (!created) return null
+
+  for (const e of created.data) {
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const f = e.parsedJson as any
+    if (f?.agent !== agentAddress) continue
+    const policyId = f.policy_id as string | undefined
+    const owner = f.owner as string | undefined
+    if (!policyId || !owner) continue
+    const pol = await client
+      .getObject({ id: policyId, options: { showContent: true } })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic Move object fields
+    const pf = (pol?.data?.content as any)?.fields
+    if (!pf || pf.revoked) continue
+
+    const ev = await client
+      .queryEvents({
+        query: { MoveEventType: `${VAULT_PKG}::vault::VaultOpened` },
+        limit: 200,
+        order: 'descending',
+      })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const match = ev?.data.find(x => (x.parsedJson as any)?.policy_id === policyId)
+    // biome-ignore lint/suspicious/noExplicitAny: parsed Move event
+    const vaultId = (match?.parsedJson as any)?.vault_id as string | undefined
+    if (!vaultId) continue
+    const v = await client
+      .getObject({ id: vaultId, options: { showContent: true } })
+      .catch(() => null)
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic Move object fields
+    const vaultMist = String((v?.data?.content as any)?.fields?.balance ?? '0')
+    return { policyId, vaultId, owner, vaultMist }
+  }
+  return null
+}
+
 /** Find the owner's policy (delegating to their derived agent) + its SUI vault. */
 export async function resolveOwnerVault(
   owner: string,

package/src/derive.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { deriveAgentAddress, deriveAgentKeypair } from './derive'
-
-const MASTER = 'a'.repeat(64)
-const A = '0x46e37419c58981bb69100fa559baa52fd7e219486d75e9dc3f0896fab01d06f5'
-const B = '0x250880a4c1a268da8011b164f599d4e100cefce84f862d36396cd1a943ee8a35'
-
-describe('agent derivation', () => {
-  it('is deterministic for the same owner + master', () => {
-    expect(deriveAgentAddress(A, MASTER)).toBe(deriveAgentAddress(A, MASTER))
-  })
-
-  it('gives distinct agents for distinct owners', () => {
-    expect(deriveAgentAddress(A, MASTER)).not.toBe(deriveAgentAddress(B, MASTER))
-  })
-
-  it('is case-insensitive on the owner address', () => {
-    expect(deriveAgentAddress(A.toUpperCase().replace('0X', '0x'), MASTER)).toBe(
-      deriveAgentAddress(A, MASTER),
-    )
-  })
-
-  it('changes with the master secret (no master reuse leaks)', () => {
-    expect(deriveAgentAddress(A, MASTER)).not.toBe(deriveAgentAddress(A, `${'b'.repeat(64)}`))
-  })
-
-  it('returns a valid 32-byte Sui address', () => {
-    expect(deriveAgentAddress(A, MASTER)).toMatch(/^0x[0-9a-f]{64}$/)
-  })
-
-  it('the keypair signs (a real Ed25519 key)', async () => {
-    const kp = deriveAgentKeypair(A, MASTER)
-    const { signature } = await kp.signPersonalMessage(new TextEncoder().encode('hi'))
-    expect(typeof signature).toBe('string')
-    expect(signature.length).toBeGreaterThan(0)
-  })
-
-  it('rejects a too-short master secret', () => {
-    expect(() => deriveAgentAddress(A, 'short')).toThrow()
-  })
-
-  it('rejects a malformed owner address', () => {
-    expect(() => deriveAgentAddress('not-an-address', MASTER)).toThrow()
-  })
-})

package/src/minimums.test.ts

@@ -1,36 +0,0 @@
-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')
-  })
-})