@kaleidorg/mind 0.7.0 → 0.8.1

package/src/testing/mock-wallet.ts

@@ -11,6 +11,7 @@
 
 import { bindWalletTools, type WalletHandler } from '../wallet/contract.js';
 import { ToolRegistry } from '../tools/registry.js';
+import { bindSubmarineTools, type SubmarineHandler } from '../submarine/contract.js';
 
 export interface SendRecord {
   tool: string;
@@ -28,6 +29,8 @@ export interface MockWalletOptions {
   assets?: Record<string, number>;
   /** Free colored UTXOs on the RLN node (issuance / RGB receive consume one). */
   utxos?: number;
+  /** Liquid balances in smallest units (L-USDT: 8 decimals, L-BTC: sats) for submarine swaps. */
+  liquid?: { 'L-USDT': number; 'L-BTC': number };
 }
 export interface MockRgbAsset {
   asset_id: string;
@@ -52,23 +55,31 @@ export class MockWallet {
   assets: Record<string, number>;
   contacts: MockContact[];
   utxos: number;
+  liquid: { 'L-USDT': number; 'L-BTC': number };
+  /** Submarine swaps opened against the mock /v2 maker, by id. */
+  submarineSwaps: Record<string, { from: 'L-USDT' | 'L-BTC'; invoice: string; expected: number; funded: boolean }> = {};
   /** RGB assets the node knows about (seeded USDT/XAUT + anything issued). */
   rgbAssets: MockRgbAsset[];
   transfers: MockTransfer[] = [];
   sends: SendRecord[] = [];
 
+  private readonly opts: MockWalletOptions;
+
   constructor(o: MockWalletOptions = {}) {
+    this.opts = o;
     this.priceUsd = o.priceUsd ?? 65_000;
     this.failRoute = o.failRoute ?? false;
-    this.balances = o.balances ?? { spark: 500_000, rln: 300_000, arkade: 200_000 };
-    this.assets = o.assets ?? { USDT: 25_000_000, XAUT: 0 };
-    this.contacts = o.contacts ?? [
+    // Copies: the wallet mutates its state, and reset() rebuilds from `o`.
+    this.balances = { ...(o.balances ?? { spark: 500_000, rln: 300_000, arkade: 200_000 }) };
+    this.assets = { ...(o.assets ?? { USDT: 25_000_000, XAUT: 0 }) };
+    this.contacts = o.contacts ? [...o.contacts] : [
       { name: 'bob', ln_address: 'bob@kaleidoswap.com' },
       { name: 'alice', ln_address: 'alice@kaleidoswap.com' },
       { name: 'john', ln_address: 'john.smith@kaleidoswap.com' },
       { name: 'john', ln_address: 'john.doe@kaleidoswap.com' }, // ambiguous on purpose
     ];
     this.utxos = o.utxos ?? 5;
+    this.liquid = { ...(o.liquid ?? { 'L-USDT': 100 * 1e8, 'L-BTC': 200_000 }) };
     this.rgbAssets = Object.keys(this.assets).map((ticker) => ({
       asset_id: mockAssetId(ticker),
       ticker,
@@ -112,9 +123,9 @@ export class MockWallet {
   totalSats(): number {
     return this.balances.spark + this.balances.rln + this.balances.arkade;
   }
+  /** Back to the constructor state: balances, contacts, UTXOs, issued assets, history. */
   reset(): void {
-    this.sends = [];
-    this.transfers = [];
+    Object.assign(this, new MockWallet(this.opts));
   }
 
   private send(tool: string, rec: { to: string; amount_sats?: number; asset?: string; amount?: number }) {
@@ -196,10 +207,56 @@ export class MockWallet {
     };
   }
 
+  /**
+   * The KaleidoSwap /v2 submarine contract against a toy maker: 0.5% fee, the
+   * invoice amount read from its BOLT11 human-readable part, L-USDT at `priceUsd`.
+   */
+  submarineHandlers(): Record<string, SubmarineHandler> {
+    return {
+      kaleidoswap_submarine_pairs: async () => ({
+        pairs: [
+          { from: 'L-USDT', to: 'BTC', fees: { percentage: 0.5 }, limits: { minimal: 10 * 1e8, maximal: 1_000 * 1e8 } },
+          { from: 'L-BTC', to: 'BTC', fees: { percentage: 0.5 }, limits: { minimal: 10_000, maximal: 1_000_000 } },
+        ],
+      }),
+      kaleidoswap_submarine_create: async ({ invoice, from_asset }) => {
+        const from = (from_asset ?? 'L-USDT') as 'L-USDT' | 'L-BTC';
+        if (from !== 'L-USDT' && from !== 'L-BTC') throw new Error(`Unsupported from_asset "${String(from_asset)}".`);
+        const sats = bolt11Sats(String(invoice));
+        if (sats == null) throw new Error('invalid_invoice: the invoice must be BOLT11 with an amount.');
+        const withFee = sats * 1.005;
+        const expected = Math.ceil(from === 'L-USDT' ? (withFee / 1e8) * this.priceUsd * 1e8 : withFee);
+        const id = `sub${Object.keys(this.submarineSwaps).length + 1}`;
+        this.submarineSwaps[id] = { from, invoice: String(invoice), expected, funded: false };
+        return { swap_id: id, from_asset: from, expected_amount: String(expected), lockup_address: `tlq1qmock${id}` };
+      },
+      kaleidoswap_submarine_fund: async ({ swap_id }) => {
+        const swap = this.submarineSwaps[String(swap_id)];
+        if (!swap) throw new Error(`No submarine swap "${String(swap_id)}" was created by this server.`);
+        if (swap.funded) throw new Error(`Swap ${String(swap_id)} is already funded.`);
+        if (this.liquid[swap.from] < swap.expected) throw new Error(`Insufficient ${swap.from} balance.`);
+        this.liquid[swap.from] -= swap.expected;
+        swap.funded = true;
+        this.sends.push({ tool: 'kaleidoswap_submarine_fund', to: swap.invoice, asset: swap.from, amount: swap.expected });
+        return { funded: true, swap_id, asset: swap.from, amount: String(swap.expected), txid: `mocktx${String(swap_id)}` };
+      },
+      kaleidoswap_submarine_status: async ({ swap_id }) => {
+        const swap = this.submarineSwaps[String(swap_id)];
+        if (!swap) throw new Error(`invalid_swap_id: "${String(swap_id)}" is not a swap id`);
+        const status = swap.funded ? 'transaction.claimed' : 'swap.created';
+        return { swap_id, status, done: swap.funded, failed: false, funded: swap.funded };
+      },
+    };
+  }
+
   /** Bind the contract tools to this wallet (optionally overriding some — e.g. to inject). */
   registry(overrides?: Partial<Record<string, WalletHandler>>): ToolRegistry {
     const h = { ...this.handlers(), ...(overrides ?? {}) } as Record<string, WalletHandler>;
-    return new ToolRegistry([bindWalletTools(h, { layers: ['spark', 'rln', 'arkade', 'core'], allowMissing: true })]);
+    const sub = { ...this.submarineHandlers(), ...(overrides ?? {}) } as Record<string, SubmarineHandler>;
+    return new ToolRegistry([
+      bindWalletTools(h, { layers: ['spark', 'rln', 'arkade', 'core'], allowMissing: true }),
+      bindSubmarineTools(sub, { allowMissing: true }),
+    ]);
   }
 }
 
@@ -209,3 +266,13 @@ function mockAssetId(ticker: string): string {
   for (const c of ticker) h = (h * 31 + c.charCodeAt(0)) >>> 0;
   return `rgb:mock-${ticker.toLowerCase()}-${h.toString(36)}`;
 }
+
+/** Amount in sats from a BOLT11 human-readable part ("lntbs10u…" → 1000), or null. */
+function bolt11Sats(invoice: string): number | null {
+  const m = invoice.toLowerCase().match(/^ln(?:bcrt|tbs|bc|tb)(\d+)([munp])?1/);
+  if (!m) return null;
+  const n = Number(m[1]);
+  const mult = { m: 1e5, u: 100, n: 0.1, p: 0.0001 }[m[2] ?? ''] ?? 1e8;
+  const sats = n * mult;
+  return sats >= 1 ? Math.round(sats) : null;
+}

package/src/wallet/confirm.ts

@@ -31,7 +31,7 @@ function isRef(s: string): boolean {
 /** Shorten an address/invoice for speech; leave contact names intact. */
 function shortRef(s: string): string {
   const v = s.trim();
-  return isRef(v) ? `${v.slice(0, 6)}…${v.slice(-4)}` : v;
+  return isRef(v) && v.length > 12 ? `${v.slice(0, 6)}…${v.slice(-4)}` : v;
 }
 
 /** " over Spark" suffix for the call's layer (explicit arg wins, else the tool's). */
@@ -41,8 +41,26 @@ function over(name: string, args: Record<string, unknown>): string {
   return label ? ` over ${label}` : '';
 }
 
-const sats = (v: unknown) => `${fmtNum(Number(v))} sats`;
-const asset = (amount: unknown, ticker: unknown) => `${fmtNum(Number(amount))} ${String(ticker)}`;
+/** A finite number from a tool arg, else undefined (never NaN in a readback). */
+function num(v: unknown): number | undefined {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : undefined;
+  if (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v))) return Number(v);
+  return undefined;
+}
+
+/** A display string from a tool arg, stripped of stray quotes/commas a model may leave in. */
+function label(v: unknown): string {
+  return String(v ?? '').trim().replace(/^[\s'"`,]+|[\s'"`,]+$/g, '') || '?';
+}
+
+const sats = (v: unknown) => {
+  const n = num(v);
+  return n === undefined ? 'an unspecified amount of sats' : `${fmtNum(n)} sats`;
+};
+const asset = (amount: unknown, ticker: unknown) => {
+  const n = num(amount);
+  return n === undefined ? `an unspecified amount of ${label(ticker)}` : `${fmtNum(n)} ${label(ticker)}`;
+};
 
 /** A spoken confirmation ending in "Confirm?", or null for non-spend tools. */
 export function confirmReadback(call: { name: string; arguments: Record<string, unknown> }): string | null {
@@ -68,18 +86,18 @@ export function confirmReadback(call: { name: string; arguments: Record<string,
     case 'spark_pay_invoice':
       return ask(`Pay Lightning invoice ${shortRef(String(a.invoice ?? ''))}${over(name, a)}`);
     case 'rln_issue_asset': {
-      const label = a.name != null && a.ticker != null && String(a.name) !== String(a.ticker) ? ` (${String(a.name)})` : '';
+      const named = a.name != null && a.ticker != null && label(a.name) !== label(a.ticker) ? ` (${label(a.name)})` : '';
       return a.schema === 'UDA'
-        ? ask(`Issue unique asset ${String(a.ticker ?? a.name)}${label} on RGB`)
-        : ask(`Issue ${asset(a.amount, a.ticker ?? a.name)}${label}, a new RGB asset`);
+        ? ask(`Issue unique asset ${label(a.ticker ?? a.name)}${named} on RGB`)
+        : ask(`Issue ${asset(a.amount, a.ticker ?? a.name)}${named}, a new RGB asset`);
     }
     case 'rln_create_utxos':
-      return ask(`Create ${fmtNum(Number(a.num ?? 5))} RGB UTXOs on-chain${over(name, a)}`);
+      return ask(`Create ${fmtNum(num(a.num) ?? 5)} RGB UTXOs on-chain${over(name, a)}`);
     case 'rln_send_btc':
       return ask(`Send ${sats(a.amount_sat)} on-chain to ${to('address')}${over(name, a)}`);
     case 'rln_open_channel': {
       const peer = shortRef(String(a.peer_pubkey_and_addr ?? '').split('@')[0] ?? '');
-      const withAsset = a.asset_id != null && a.asset_amount != null ? ` with ${fmtNum(Number(a.asset_amount))} of ${shortRef(String(a.asset_id))}` : '';
+      const withAsset = a.asset_id != null && num(a.asset_amount) !== undefined ? ` with ${fmtNum(num(a.asset_amount)!)} of ${shortRef(String(a.asset_id))}` : '';
       return ask(`Open a ${sats(a.capacity_sat)} channel to ${peer}${withAsset}`);
     }
     case 'rln_close_channel':
@@ -87,7 +105,7 @@ export function confirmReadback(call: { name: string; arguments: Record<string,
     case 'rln_atomic_taker':
       return ask(`Accept atomic swap ${shortRef(String(a.swapstring ?? ''))} on your node`);
     case 'execute_swap':
-      return ask(`Swap ${fmtNum(Number(a.amount))} ${String(a.from_asset)} for ${String(a.to_asset)}`);
+      return ask(`Swap ${asset(a.amount, a.from_asset)} for ${label(a.to_asset)}`);
     default:
       // Unknown but spend-flagged tool → a generic, still-honest readback.
       return getWalletTool(name)?.spend ? ask(`Confirm ${name.replace(/_/g, ' ')}`) : null;