lyra-plugin-onchain 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# lyra-plugin-onchain
+
+The **Sui limbs** for **lyra** — the brain tools that do real on-chain work,
+every value-moving call routed through the deterministic policy → simulation →
+approval pipeline:
+
+- **Wallet / account** — `account.info`, `chain.balance`, `tokens.info`
+- **Transfers** — `chain.send`, `chain.wrap`, `chain.unwrap`
+- **Trading** — `swap.best` / `swap.compare` (**Cetus Finance** + **DeepBook**
+  best-execution), `swap.quote` / `swap.execute`, `moe.quote` / `moe.swap`
+- **Lending** — full **Scallop V3** suite: `scallop.markets` / `position` / `supply` /
+  `withdraw` / `borrow` / `repay`
+- **Discovery + risk** — `defi.yields` (DeFiLlama), `risk.token`, `nansen.labels`,
+  `cex.balance` (Bybit, read-only)
+- **Identity** — `identity.resolve` / `identity.register` (**lyra::policy** Trustless
+  Agents)
+- **Controls + analysis** — `policy.show`, `tx.simulate`, `chain.read` /
+  `chain.write`, `chain.tx` / `chain.contract` / `chain.activity`, `chain.block` /
+  `chain.gas`
+
+## Install
+
+Auto-installed with [`lyra-ai-agent`](https://www.npmjs.com/package/lyra-ai-agent).
+Or directly: `bun add lyra-plugin-onchain`.
+
+See the [root README](https://github.com/rifkyeasy/lyra#readme) for the full tool reference.

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "lyra-plugin-onchain",
+  "version": "0.1.0",
+  "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",
+  "homepage": "https://github.com/rifkyeasy/lyra",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rifkyeasy/lyra.git",
+    "directory": "packages/plugin-onchain"
+  },
+  "bugs": {
+    "url": "https://github.com/rifkyeasy/lyra/issues"
+  },
+  "keywords": [
+    "lyra",
+    "ai",
+    "agent",
+    "sui",
+    "defi",
+    "deepbook",
+    "walrus",
+    "policy",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.1"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "README.md"
+  ],
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "build": "tsc -b",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@7kprotocol/sdk-ts": "^4.0.0",
+    "@cetusprotocol/aggregator-sdk": "^1.6.1",
+    "@mysten/deepbook-v3": "^0.18.0",
+    "@mysten/sui": "^1.40.0",
+    "@mysten/walrus": "^0.6.4",
+    "@scallop-io/sui-scallop-sdk": "^2.4.5",
+    "lyra-core": "0.3.3",
+    "navi-sdk": "^1.7.3",
+    "zod": "^3.23.8"
+  }
+}

package/src/approval.ts

@@ -0,0 +1,50 @@
+/**
+ * Permission-gate bridge between the deterministic policy engine and the
+ * harness permission service.
+ *
+ * The CLI + gateway pre-tool-call hooks build a permission request for every
+ * value-moving tool call. On its own the permission service only knows the
+ * session MODE (strict/prompt/off) — under YOLO it would let any in-cap spend
+ * through silently. This helper runs the SAME `evaluatePolicy` the tool runs and,
+ * when the policy flags the action as material-risk (`requiresApproval`), the
+ * hook forces an approval prompt beneath the session mode. Fund controls in
+ * code, not in the model (CLAUDE.md).
+ */
+
+import { type SuiPolicy, type SuiPolicyAction, evaluatePolicy, suiToMist } from './policy'
+
+const SUI_TYPE = '0x2::sui::SUI'
+
+/** Map a tool call (name + raw args) to a best-effort PolicyAction. */
+function actionForCall(name: string, a: Record<string, unknown>): SuiPolicyAction | null {
+  switch (name) {
+    case 'sui.send': {
+      const amount = typeof a.amount === 'string' ? a.amount : String(a.amount ?? '')
+      return {
+        kind: 'transfer',
+        coinType: SUI_TYPE,
+        amountMist: suiToMist(amount) ?? 0n,
+        to: typeof a.to === 'string' ? a.to : undefined,
+        protocol: 'transfer',
+      }
+    }
+    default:
+      return null
+  }
+}
+
+/**
+ * True when the policy requires human approval for this tool call (the gate
+ * should force a prompt regardless of mode). False when no policy is configured
+ * or the call is not value-moving.
+ */
+export function policyRequiresApprovalForCall(
+  name: string,
+  args: Record<string, unknown>,
+  policy: SuiPolicy | undefined,
+): boolean {
+  if (!policy) return false
+  const action = actionForCall(name, args)
+  if (!action) return false
+  return evaluatePolicy(action, policy).requiresApproval
+}

package/src/client.ts

@@ -0,0 +1,32 @@
+/**
+ * Sui client + agent keypair construction for Lyra's on-chain plugin.
+ *
+ * One agent address signs and pays gas. The deterministic policy (off-chain
+ * mirror in `./policy.ts`, enforced again on-chain by `lyra::policy`) bounds
+ * what it may do.
+ */
+
+import { SuiClient, getFullnodeUrl } from '@mysten/sui/client'
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
+
+export type SuiNetwork = 'testnet' | 'mainnet'
+
+/** Canonical fullnode JSON-RPC URL for a network. */
+export function suiRpcUrl(network: SuiNetwork): string {
+  return getFullnodeUrl(network)
+}
+
+/** A Sui JSON-RPC client for the given network. */
+export function makeSuiClient(network: SuiNetwork): SuiClient {
+  return new SuiClient({ url: getFullnodeUrl(network) })
+}
+
+/**
+ * Build the agent keypair from a secret. Accepts a Sui bech32 secret
+ * (`suiprivkey1...`, preferred) or a base64-encoded 32-byte seed.
+ */
+export function keypairFromSecret(secret: string): Ed25519Keypair {
+  const s = secret.trim()
+  if (s.startsWith('suiprivkey')) return Ed25519Keypair.fromSecretKey(s)
+  return Ed25519Keypair.fromSecretKey(Uint8Array.from(Buffer.from(s, 'base64')))
+}

package/src/derive.test.ts

@@ -0,0 +1,45 @@
+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/derive.ts

@@ -0,0 +1,39 @@
+/**
+ * Multi-tenant agent derivation — the canonical algorithm shared by every Lyra
+ * surface (CLI, gateway, Telegram). Each owner wallet gets ONE deterministic
+ * agent keypair, derived from a single server master secret. No per-user key
+ * storage; the same owner always resolves to the same agent everywhere.
+ *
+ * The web mirrors this byte-for-byte in `apps/web/lib/agent-derive.ts` — keep the
+ * domain string + HMAC construction identical or the two will diverge.
+ *
+ * The owner authenticates per interface (SIWS on web, /link on Telegram, local
+ * config on CLI); the on-chain `lyra::policy` AgentPolicy(owner, agent) records
+ * the binding and bounds what the derived agent may spend.
+ */
+
+import { createHmac } from 'node:crypto'
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
+
+const DERIVATION_DOMAIN = 'lyra-agent:v1:'
+
+/** Derive the agent keypair belonging to `ownerAddress`. */
+export function deriveAgentKeypair(
+  ownerAddress: string,
+  masterSecret: string | undefined = process.env.LYRA_MASTER_SECRET,
+): Ed25519Keypair {
+  if (!masterSecret || masterSecret.length < 32) {
+    throw new Error('LYRA_MASTER_SECRET is not configured (need ≥32 chars)')
+  }
+  const owner = ownerAddress.trim().toLowerCase()
+  if (!/^0x[0-9a-f]{1,64}$/.test(owner)) throw new Error(`invalid owner address: ${ownerAddress}`)
+  const seed = createHmac('sha256', masterSecret)
+    .update(DERIVATION_DOMAIN + owner)
+    .digest()
+  return Ed25519Keypair.fromSecretKey(new Uint8Array(seed))
+}
+
+/** The Sui address of the agent belonging to `ownerAddress`. */
+export function deriveAgentAddress(ownerAddress: string, masterSecret?: string): string {
+  return deriveAgentKeypair(ownerAddress, masterSecret).toSuiAddress()
+}

package/src/guidance.ts

@@ -0,0 +1,47 @@
+/**
+ * System-prompt guidance injected when the onchain plugin is active. Tells the
+ * brain what the Sui tools do and — critically — that the policy is enforced in
+ * code and on-chain, not by the model.
+ */
+
+export const ONCHAIN_GUIDANCE = `# Sui on-chain tools (Lyra)
+
+You operate a single Sui agent address. You can read and move funds ONLY through
+these tools; every value-moving action is checked by a deterministic policy in
+code AND re-enforced on-chain by the lyra::policy Move package. You cannot talk
+your way past a cap — if a transfer exceeds the per-tx cap or budget, the tool
+returns "policy blocked" before anything is signed.
+
+Read-only / discovery:
+- account.info — the agent's Sui address, network, balance, and active policy.
+- sui.balance — SUI and coin balances for the agent or any address.
+- policy.show — the active fund-control policy (caps, allowlists, expiry, tier).
+- protocols.list — which protocols Lyra can READ vs EXECUTE on.
+- defi.yields — best yields across ALL Sui protocols (DefiLlama). Each result is
+  tagged executable / executeWith.
+- deepbook.markets — DeepBook spot mid prices.
+- cetus.quote — best swap route/price across many DEXes (aggregator, read-only).
+- scallop.markets / scallop.position, navi.markets / navi.position — lending
+  rates + the agent's positions.
+
+Writes (policy-checked → simulated → executed):
+- policy.create — publish a shared on-chain AgentPolicy (budget, per-tx cap,
+  expiry). Do this first to arm on-chain enforcement + receipts.
+- sui.send — transfer SUI. Blocked if out of policy; mints an on-chain receipt.
+- scallop.supply / scallop.withdraw, navi.supply / navi.withdraw — lend or
+  redeem idle SUI on Scallop / NAVI (the two largest Sui money markets).
+- walrus.store — persist a receipt/report/memory artifact to Walrus.
+
+The capability boundary (important):
+- Discovery is broad; EXECUTION is bounded. Lyra can only act on the protocols in
+  protocols.list (currently Scallop + NAVI lending, Sui transfers, Walrus).
+- If the best yield a user wants is on a protocol Lyra has NOT integrated, DO NOT
+  invent a transaction. Say so honestly, then offer: (a) the best executable
+  alternative (e.g. supply on NAVI/Scallop), or (b) concise manual steps. The
+  policy's protocol-allowlist enforces this on-chain too.
+
+Rules:
+- Call policy.show / protocols.list before claiming what you can spend or do.
+- When an action is blocked or needs approval, explain why using the policy; do
+  not retry to get around it.
+- Prefer storing an execution receipt to Walrus after a successful write.`

package/src/index.ts

@@ -0,0 +1,94 @@
+/**
+ * lyra-plugin-onchain
+ *
+ * Brain limbs for on-chain operations on Sui:
+ *
+ *   Account:     account.info, sui.balance
+ *   Transfers:   sui.send            (policy → simulate → execute → on-chain receipt)
+ *   Policy:      policy.show, policy.create   (lyra::policy AgentPolicy)
+ *   Storage:     walrus.store        (durable, verifiable receipts/memory)
+ *   Markets:     deepbook.markets    (DeepBook spot mid prices, read-only)
+ *
+ * Value-moving tools run through policy → simulate → (approval) → execute, and
+ * are re-enforced on-chain by the lyra::policy Move package.
+ *
+ * Runtime ctx is side-banded onto PluginContext under `.onchain` (see
+ * `OnchainRuntimeContext` in `./types.ts`). Without it the plugin registers
+ * nothing — a graceful no-op for unit-test loaders.
+ */
+
+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 { makePolicyCreate, makePolicyShow } from './tools/policy'
+import { makeProtocolsList } from './tools/protocols'
+import {
+  makeScallopMarkets,
+  makeScallopPosition,
+  makeScallopSupply,
+  makeScallopWithdraw,
+} from './tools/scallop'
+import { makeSuiSend } from './tools/send'
+import { makeSwap } from './tools/swap'
+import { makeWalrusStore } from './tools/walrus'
+import type { OnchainRuntimeContext } from './types'
+
+export {
+  makeSuiClient,
+  keypairFromSecret,
+  suiRpcUrl,
+  type SuiNetwork,
+} from './client'
+export { simulate, type SimResult } from './simulate'
+export {
+  evaluatePolicy,
+  policyFromEnv,
+  suiToMist,
+  normalizeCoinType,
+  MIST_PER_SUI,
+  type SuiPolicy,
+  type SuiPolicyAction,
+  type PolicyVerdict,
+} from './policy'
+export { policyRequiresApprovalForCall } from './approval'
+export { deriveAgentKeypair, deriveAgentAddress } from './derive'
+export { resolveOwnerVault, type OwnerVault } from './vault'
+export { ONCHAIN_GUIDANCE } from './guidance'
+export type { OnchainRuntimeContext } from './types'
+
+const plugin: NativePlugin = {
+  name: 'onchain',
+  register: ctx => {
+    const onchain = (ctx as unknown as { onchain?: OnchainRuntimeContext }).onchain
+    if (!onchain) return // soft-init for tests / non-onchain contexts
+
+    ctx.registerTool(makeAccountInfo(onchain) as ToolDef)
+    ctx.registerTool(makeSuiBalance(onchain) as ToolDef)
+    ctx.registerTool(makeSuiSend(onchain) as ToolDef)
+    ctx.registerTool(makeSwap(onchain) as ToolDef)
+    ctx.registerTool(makePolicyShow(onchain) as ToolDef)
+    ctx.registerTool(makePolicyCreate(onchain) as ToolDef)
+    ctx.registerTool(makeWalrusStore(onchain) as ToolDef)
+    ctx.registerTool(makeDeepbookMarkets(onchain) as ToolDef)
+
+    // Discovery + capability map.
+    ctx.registerTool(makeProtocolsList(onchain) as ToolDef)
+    ctx.registerTool(makeDefiYields(onchain) as ToolDef)
+    ctx.registerTool(makeCetusQuote(onchain) as ToolDef)
+
+    // Lending (the two largest Sui money markets).
+    ctx.registerTool(makeScallopMarkets(onchain) as ToolDef)
+    ctx.registerTool(makeScallopPosition(onchain) as ToolDef)
+    ctx.registerTool(makeScallopSupply(onchain) as ToolDef)
+    ctx.registerTool(makeScallopWithdraw(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)
+  },
+}
+
+export default plugin

package/src/policy.test.ts

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