@lombard.finance/sdk-solana 1.2.2 → 2.0.0

package/src/web3Sdk/redeem/redeem.ts

@@ -0,0 +1,352 @@
+import { BN, Program } from '@coral-xyz/anchor';
+import { Env } from '@lombard.finance/sdk-common';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddress,
+} from '@solana/spl-token';
+import { PublicKey, SystemProgram } from '@solana/web3.js';
+
+import { DEFAULT_ENV, getConfig, networkToEnv } from '../../const/getConfig';
+import { getConnection } from '../../const/rpcUrls';
+import { getAssetRouterIdl } from '../../idl/getAssetRouterIdl';
+import { ISolanaWalletProvider, SolanaNetwork } from '../../types';
+import {
+  ErrorCode,
+  sendAndConfirmTransaction,
+  SolanaSdkError,
+} from '../../utils';
+import { createDebugLogger } from '../../utils/createDebugLogger';
+import { getTokenProgramForMint } from '../../utils/tokenAccount';
+import { validateAmount } from '../redeemToken/shared';
+
+export interface RedeemParams {
+  amount: string;
+  /**
+   * Owner wallet that receives the routed destination token (e.g. BTC.b).
+   * Solana pubkey (base58). The GMP payload uses the ATA for Asset Router
+   * `native_mint` from on-chain config and this owner — matching backend/claimer expectations.
+   */
+  recipient: string;
+  /**
+   * Source token mint to burn. Defaults to `config.lbtcTokenMint`.
+   */
+  tokenMint?: string;
+  /**
+   * Destination Lombard routing chain ID (hex, 32 bytes).
+   * Defaults to `config.solanaRoutingChainId` (same-chain redeem).
+   */
+  toLchainId?: string;
+  /**
+   * Destination token address / mint. Defaults to `config.btcbTokenMint`.
+   */
+  toTokenAddress?: string;
+  network: SolanaNetwork;
+  /**
+   * Optional environment override. When provided, used instead of
+   * the default `networkToEnv[network]` mapping to resolve config.
+   */
+  env?: Env;
+  rpcUrl?: string;
+  debug?: boolean;
+  /**
+   * Skip preflight transaction simulation before broadcast.
+   */
+  skipPreflight?: boolean;
+}
+
+/**
+ * Redeem tokens via Asset Router's generic `redeem` instruction.
+ *
+ * Burns the source token and sends a GMP message through the Mailbox
+ * to route the destination token to the recipient's ATA for `native_mint`.
+ *
+ * Default flow (all optional params omitted): LBTC → BTC.b on Solana.
+ */
+export async function redeem(
+  provider: ISolanaWalletProvider,
+  params: RedeemParams,
+): Promise<string> {
+  const {
+    amount, recipient, network,
+    env: envOverride, rpcUrl,
+    debug = false, skipPreflight = true,
+  } = params;
+  const { debugLog, printLogs } = createDebugLogger({ debug });
+
+  try {
+    if (!provider.publicKey) {
+      throw new Error('Wallet not connected');
+    }
+
+    const env = envOverride ?? networkToEnv[network] ?? DEFAULT_ENV;
+    const config = getConfig(env);
+
+    if (!config.assetRouter) {
+      throw new Error(`Asset Router not configured for network: ${network}`);
+    }
+    if (!config.mailbox) {
+      throw new Error(`Mailbox not configured for network: ${network}`);
+    }
+    if (!config.solanaRoutingChainId) {
+      throw new Error(`Solana routing chain ID not configured for network: ${network}`);
+    }
+
+    // Resolve source token mint (defaults to LBTC)
+    const mintAddress = params.tokenMint || config.lbtcTokenMint;
+    if (!mintAddress) {
+      throw new Error(`Source token mint not configured for network: ${network}`);
+    }
+
+    // Resolve destination chain and token (defaults to Solana + BTC.b)
+    const toLchainIdHex = params.toLchainId || config.solanaRoutingChainId;
+    const toTokenAddressStr = params.toTokenAddress || config.btcbTokenMint;
+    if (!toTokenAddressStr) {
+      throw new Error(`Destination token not configured for network: ${network}`);
+    }
+
+    validateAmount(amount);
+
+    const connection = getConnection(network, rpcUrl);
+    const payer = new PublicKey(provider.publicKey);
+    const mint = new PublicKey(mintAddress);
+    const recipientPubkey = new PublicKey(recipient);
+    const assetRouterProgramId = new PublicKey(config.assetRouter);
+    const mailboxProgramId = new PublicKey(config.mailbox);
+    const solanaRoutingChainId = Buffer.from(config.solanaRoutingChainId, 'hex');
+    const toLchainId = Buffer.from(toLchainIdHex, 'hex');
+    const toTokenAddress = new PublicKey(toTokenAddressStr).toBytes();
+
+    debugLog('Payer:', payer.toBase58());
+    debugLog('Mint (source):', mint.toBase58());
+    debugLog('Destination token (route arg):', toTokenAddressStr);
+    debugLog('Recipient (owner):', recipientPubkey.toBase58());
+    debugLog('Amount:', amount);
+
+    // ── Detect token program (Token vs Token-2022) ──
+    const tokenProgramId = await getTokenProgramForMint(connection, mint);
+    debugLog('Token program:', tokenProgramId.toBase58());
+
+    // ── Asset Router PDAs ──
+    const [assetRouterConfigPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('asset_router_config')],
+      assetRouterProgramId,
+    );
+    const [tokenConfigPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('token_config'), mint.toBuffer()],
+      assetRouterProgramId,
+    );
+    const [tokenRoutePDA] = PublicKey.findProgramAddressSync(
+      [
+        Buffer.from('token_route'),
+        solanaRoutingChainId,
+        mint.toBuffer(),
+        toLchainId,
+        Buffer.from(toTokenAddress),
+      ],
+      assetRouterProgramId,
+    );
+    const [messagingAuthorityPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('messaging_authority')],
+      assetRouterProgramId,
+    );
+
+    debugLog('Asset Router config PDA:', assetRouterConfigPDA.toBase58());
+    debugLog('Token config PDA:', tokenConfigPDA.toBase58());
+    debugLog('Token route PDA:', tokenRoutePDA.toBase58());
+    debugLog('Messaging authority PDA:', messagingAuthorityPDA.toBase58());
+
+    // ── Mailbox PDAs ──
+    const [mailboxConfigPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('mailbox_config')],
+      mailboxProgramId,
+    );
+    if (!config.ledgerChainId) {
+      throw new Error(`Ledger chain ID not configured for network: ${network}`);
+    }
+    const ledgerChainId = Buffer.from(config.ledgerChainId, 'hex');
+    const [outboundMessagePathPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('outbound_message_path'), ledgerChainId],
+      mailboxProgramId,
+    );
+    const [senderConfigPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('sender_config'), assetRouterProgramId.toBuffer()],
+      mailboxProgramId,
+    );
+
+    debugLog('Mailbox config PDA:', mailboxConfigPDA.toBase58());
+    debugLog('Outbound message path PDA:', outboundMessagePathPDA.toBase58());
+    debugLog('Sender config PDA:', senderConfigPDA.toBase58());
+
+    // ── Read on-chain state ──
+    const [arConfigInfo, mailboxConfigInfo] = await Promise.all([
+      connection.getAccountInfo(assetRouterConfigPDA),
+      connection.getAccountInfo(mailboxConfigPDA),
+    ]);
+
+    if (!arConfigInfo) {
+      throw new Error('Asset Router config account not found');
+    }
+    if (!mailboxConfigInfo) {
+      throw new Error('Mailbox config account not found');
+    }
+
+    if (arConfigInfo.data.length < 137) {
+      throw new Error(
+        `Asset Router config account data too short: expected >= 137 bytes (treasury, paused, native_mint), got ${arConfigInfo.data.length}`,
+      );
+    }
+    const arTreasury = new PublicKey(arConfigInfo.data.subarray(72, 104));
+    const paused = arConfigInfo.data[104] !== 0;
+    const nativeMintFromConfig = new PublicKey(
+      arConfigInfo.data.subarray(105, 137),
+    );
+    if (paused) {
+      throw new Error('Asset Router is paused');
+    }
+    debugLog('Asset Router treasury:', arTreasury.toBase58());
+    debugLog('Native mint (recipient ATA mint):', nativeMintFromConfig.toBase58());
+
+    if (mailboxConfigInfo.data.length < 104) {
+      throw new Error(
+        `Mailbox config account data too short: expected >= 104 bytes, got ${mailboxConfigInfo.data.length}`,
+      );
+    }
+    const mailboxTreasury = new PublicKey(
+      mailboxConfigInfo.data.subarray(72, 104),
+    );
+    debugLog('Mailbox treasury:', mailboxTreasury.toBase58());
+
+    // ── Token accounts ──
+    const payerTokenAccount = await getAssociatedTokenAddress(
+      mint,
+      payer,
+      false,
+      tokenProgramId,
+      ASSOCIATED_TOKEN_PROGRAM_ID,
+    );
+    const treasuryTokenAccount = await getAssociatedTokenAddress(
+      mint,
+      arTreasury,
+      true,
+      tokenProgramId,
+      ASSOCIATED_TOKEN_PROGRAM_ID,
+    );
+
+    const destinationTokenProgramId = await getTokenProgramForMint(
+      connection,
+      nativeMintFromConfig,
+    );
+    const recipientTokenAccount = await getAssociatedTokenAddress(
+      nativeMintFromConfig,
+      recipientPubkey,
+      false,
+      destinationTokenProgramId,
+      ASSOCIATED_TOKEN_PROGRAM_ID,
+    );
+
+    debugLog('Payer token account:', payerTokenAccount.toBase58());
+    debugLog('Treasury token account:', treasuryTokenAccount.toBase58());
+    debugLog('Recipient token account (payload):', recipientTokenAccount.toBase58());
+
+    // ── Balance check ──
+    const tokenBalance = await connection.getTokenAccountBalance(payerTokenAccount);
+    const userBalance = BigInt(tokenBalance.value.amount);
+    const parsedAmount = BigInt(amount);
+    if (userBalance < parsedAmount) {
+      throw new Error(
+        `Insufficient balance: have ${tokenBalance.value.uiAmountString}, need ${Number(parsedAmount) / 1e8}`,
+      );
+    }
+
+    const assetRouterProgram = new Program(
+      getAssetRouterIdl(env),
+      { connection },
+    );
+
+    // ── Instruction args ──
+    const toLchainIdArray = Array.from(toLchainId);
+    const toTokenAddressArray = Array.from(toTokenAddress);
+    const recipientArray = Array.from(recipientTokenAccount.toBytes());
+
+    // ── Build & send with nonce retry ──
+    const MAX_NONCE_RETRIES = 3;
+    for (let attempt = 0; attempt < MAX_NONCE_RETRIES; attempt++) {
+      const freshMailboxConfig = await connection.getAccountInfo(mailboxConfigPDA);
+      if (!freshMailboxConfig) {
+        throw new Error('Mailbox config account not found');
+      }
+      if (freshMailboxConfig.data.length < 145) {
+        throw new Error(
+          `Mailbox config account data too short: expected >= 145 bytes, got ${freshMailboxConfig.data.length}`,
+        );
+      }
+      const globalNonce = freshMailboxConfig.data.readBigUInt64LE(137);
+      const nonceBuf = Buffer.alloc(8);
+      nonceBuf.writeBigUInt64BE(globalNonce);
+
+      const [outboundMessagePDA] = PublicKey.findProgramAddressSync(
+        [Buffer.from('outbound_message'), nonceBuf],
+        mailboxProgramId,
+      );
+
+      debugLog(`Attempt ${attempt + 1}: global nonce=${globalNonce}, outbound_message=${outboundMessagePDA.toBase58()}`);
+
+      const tx = await assetRouterProgram.methods
+        .redeem(toLchainIdArray, toTokenAddressArray, recipientArray, new BN(amount))
+        .accounts({
+          payer,
+          config: assetRouterConfigPDA,
+          tokenConfig: tokenConfigPDA,
+          tokenRoute: tokenRoutePDA,
+          payerTokenAccount,
+          tokenProgram: tokenProgramId,
+          mint,
+          treasuryTokenAccount,
+          messagingAuthority: messagingAuthorityPDA,
+          mailbox: mailboxProgramId,
+          mailboxConfig: mailboxConfigPDA,
+          outboundMessagePath: outboundMessagePathPDA,
+          outboundMessage: outboundMessagePDA,
+          senderConfig: senderConfigPDA,
+          treasury: mailboxTreasury,
+          systemProgram: SystemProgram.programId,
+        })
+        .transaction();
+
+      debugLog('Instruction account count:', tx.instructions[0]?.keys.length);
+
+      try {
+        const { signature } = await sendAndConfirmTransaction({
+          instruction: tx,
+          connection,
+          provider,
+          debugLabel: 'Asset Router redeem',
+          skipPreflight,
+        });
+
+        debugLog('redeem completed, signature:', signature);
+        return signature;
+      } catch (err: unknown) {
+        const isNonceError =
+          err instanceof Error &&
+          err.message.includes('0x7d6'); // ConstraintSeeds
+        if (isNonceError && attempt < MAX_NONCE_RETRIES - 1) {
+          debugLog(`Nonce stale (ConstraintSeeds), retrying...`);
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    throw new Error('Failed after max nonce retries');
+  } catch (error: unknown) {
+    if (error instanceof Error && debug) {
+      error.message = `${error.message}\n\nDebug logs:\n${printLogs()}`;
+    }
+    throw SolanaSdkError.wrap(
+      error,
+      ErrorCode.REDEEM_REJECTED,
+      'redeem operation failed',
+    );
+  }
+}

package/src/web3Sdk/redeemToken/redeemBtcb.ts

@@ -0,0 +1,174 @@
+import { BN } from '@coral-xyz/anchor';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddress,
+} from '@solana/spl-token';
+import { PublicKey, SystemProgram } from '@solana/web3.js';
+
+import { sendAndConfirmTransaction } from '../../utils';
+import { BTC_NATIVE_TOKEN_ADDRESS, RedeemContext } from './shared';
+
+/**
+ * BTC.b → BTC redemption via Asset Router's `redeem_for_btc`.
+ *
+ * Burns BTC.b tokens and sends a GMP message through the Mailbox to trigger
+ * a BTC payout to the specified Bitcoin address.
+ */
+export async function redeemBtcbForBtc(ctx: RedeemContext): Promise<string> {
+  const {
+    provider, params, config, connection,
+    payer, mint, tokenProgramId, scriptPubKey,
+    assetRouterProgramId, mailboxProgramId,
+    solanaRoutingChainId, bitcoinRoutingChainId,
+    assetRouterProgram, assetRouterConfigPDA, mailboxConfigPDA,
+    arTreasury, mailboxTreasury,
+    debugLog,
+  } = ctx;
+
+  const { amount, skipPreflight = false } = params;
+
+  // ── BTC.b-specific PDAs ──
+  const [tokenConfigPDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('token_config'), mint.toBuffer()],
+    assetRouterProgramId,
+  );
+  const [tokenRoutePDA] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from('token_route'),
+      solanaRoutingChainId,
+      mint.toBuffer(),
+      bitcoinRoutingChainId,
+      BTC_NATIVE_TOKEN_ADDRESS,
+    ],
+    assetRouterProgramId,
+  );
+  const [messagingAuthorityPDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('messaging_authority')],
+    assetRouterProgramId,
+  );
+
+  debugLog('Token config PDA:', tokenConfigPDA.toBase58());
+  debugLog('Token route PDA:', tokenRoutePDA.toBase58());
+  debugLog('Messaging authority PDA:', messagingAuthorityPDA.toBase58());
+
+  // ── Mailbox PDAs ──
+  if (!config.ledgerChainId) {
+    throw new Error(`Ledger chain ID not configured for network: ${params.network}`);
+  }
+  const ledgerChainId = Buffer.from(config.ledgerChainId, 'hex');
+  const [outboundMessagePathPDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('outbound_message_path'), ledgerChainId],
+    mailboxProgramId,
+  );
+  const [senderConfigPDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('sender_config'), assetRouterProgramId.toBuffer()],
+    mailboxProgramId,
+  );
+
+  debugLog('Outbound message path PDA:', outboundMessagePathPDA.toBase58());
+  debugLog('Sender config PDA:', senderConfigPDA.toBase58());
+
+  // ── Token accounts ──
+  const payerTokenAccount = await getAssociatedTokenAddress(
+    mint,
+    payer,
+    false,
+    tokenProgramId,
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+  );
+  const treasuryTokenAccount = await getAssociatedTokenAddress(
+    mint,
+    arTreasury,
+    true,
+    tokenProgramId,
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+  );
+
+  debugLog('Payer token account:', payerTokenAccount.toBase58());
+  debugLog('Treasury token account:', treasuryTokenAccount.toBase58());
+
+  // ── Balance check ──
+  const tokenBalance = await connection.getTokenAccountBalance(payerTokenAccount);
+  const userBalance = BigInt(tokenBalance.value.amount);
+  const parsedAmount = BigInt(amount);
+  if (userBalance < parsedAmount) {
+    throw new Error(
+      `Insufficient BTC.b balance: have ${tokenBalance.value.uiAmountString}, need ${Number(parsedAmount) / 1e8}`,
+    );
+  }
+
+  // ── Build & send with nonce retry ──
+  // The outbound_message PDA depends on global_nonce which can change between
+  // reads. Retry up to 3 times if the nonce becomes stale.
+  const MAX_NONCE_RETRIES = 3;
+  for (let attempt = 0; attempt < MAX_NONCE_RETRIES; attempt++) {
+    const freshMailboxConfig = await connection.getAccountInfo(mailboxConfigPDA);
+    if (!freshMailboxConfig) {
+      throw new Error('Mailbox config account not found');
+    }
+    // global_nonce is a u64 at offset 137; need 137 + 8 = 145 bytes
+    if (freshMailboxConfig.data.length < 145) {
+      throw new Error(
+        `Mailbox config account data too short: expected >= 145 bytes, got ${freshMailboxConfig.data.length}`,
+      );
+    }
+    const globalNonce = freshMailboxConfig.data.readBigUInt64LE(137);
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64BE(globalNonce);
+
+    const [outboundMessagePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('outbound_message'), nonceBuf],
+      mailboxProgramId,
+    );
+
+    debugLog(`Attempt ${attempt + 1}: global nonce=${globalNonce}, outbound_message=${outboundMessagePDA.toBase58()}`);
+
+    const tx = await assetRouterProgram.methods
+      .redeemForBtc(scriptPubKey, new BN(amount))
+      .accounts({
+        payer,
+        config: assetRouterConfigPDA,
+        tokenConfig: tokenConfigPDA,
+        tokenRoute: tokenRoutePDA,
+        payerTokenAccount,
+        tokenProgram: tokenProgramId,
+        mint,
+        treasuryTokenAccount,
+        messagingAuthority: messagingAuthorityPDA,
+        mailbox: mailboxProgramId,
+        mailboxConfig: mailboxConfigPDA,
+        outboundMessagePath: outboundMessagePathPDA,
+        outboundMessage: outboundMessagePDA,
+        senderConfig: senderConfigPDA,
+        treasury: mailboxTreasury,
+        systemProgram: SystemProgram.programId,
+      })
+      .transaction();
+
+    debugLog('Instruction account count:', tx.instructions[0]?.keys.length);
+
+    try {
+      const { signature } = await sendAndConfirmTransaction({
+        instruction: tx,
+        connection,
+        provider,
+        debugLabel: 'Asset Router redeem_for_btc',
+        skipPreflight,
+      });
+
+      debugLog('redeem_for_btc completed, signature:', signature);
+      return signature;
+    } catch (err: unknown) {
+      const isNonceError =
+        err instanceof Error &&
+        err.message.includes('0x7d6'); // ConstraintSeeds
+      if (isNonceError && attempt < MAX_NONCE_RETRIES - 1) {
+        debugLog(`Nonce stale (ConstraintSeeds), retrying...`);
+        continue;
+      }
+      throw err;
+    }
+  }
+
+  throw new Error('Failed after max nonce retries');
+}

package/src/web3Sdk/redeemToken/redeemForBtc.stories.tsx

@@ -2,7 +2,7 @@ import { Env } from '@lombard.finance/sdk-common';
 import type { Meta, StoryObj } from '@storybook/react';
 import { useState } from 'react';
 
-import { envToNetwork } from '../../const/getConfig';
+import { envToNetwork, getConfig } from '../../const/getConfig';
 import {
   Button,
   CodeBlock,
@@ -16,20 +16,27 @@ import { useConnect } from '../../stories/hooks/useConnect';
 import useQuery from '../../stories/hooks/useQuery';
 import { redeemForBtc } from './redeemForBtc';
 
+type RedeemToken = 'BTC.b' | 'LBTC';
+
 interface RedeemForBtcStoryArgs {
   environment: Env;
   amount: string;
   btcAddress: string;
-  tokenMint: string;
+  token: RedeemToken;
 }
 
+const getTokenMint = (token: RedeemToken, config: ReturnType<typeof getConfig>): string | undefined =>
+  token === 'LBTC' ? config.lbtcTokenMint : config.btcbTokenMint ?? undefined;
+
 export const StoryView = ({
   environment,
   amount,
   btcAddress,
-  tokenMint,
+  token,
 }: RedeemForBtcStoryArgs) => {
   const network = envToNetwork[environment];
+  const config = getConfig(environment);
+  const tokenMint = getTokenMint(token, config);
   const [transactionLogs, setTransactionLogs] = useState<string[] | null>(null);
 
   const {
@@ -53,12 +60,18 @@ export const StoryView = ({
 
     const amountSats = Math.round(parsedAmount * 1e8).toString();
 
+    if (!tokenMint) {
+      throw new Error(
+        'No mint for the selected token in this environment (e.g. BTC.b may be unset on mainnet).',
+      );
+    }
+
     setTransactionLogs(null);
     try {
       const result = await redeemForBtc(provider, {
         amount: amountSats,
         btcAddress,
-        tokenMint: tokenMint || undefined,
+        tokenMint,
         network,
         env: environment,
         debug: true,
@@ -80,7 +93,7 @@ export const StoryView = ({
     refetch: handleRedeem,
   } = useQuery(
     request,
-    [provider, address, amount, btcAddress, tokenMint, environment],
+    [provider, address, amount, btcAddress, token, environment],
     false,
   );
 
@@ -112,11 +125,10 @@ export const StoryView = ({
             <p>
               <strong>BTC Address:</strong> {btcAddress || <em>Not set</em>}
             </p>
-            {tokenMint && (
-              <p>
-                <strong>Token Mint Override:</strong> {tokenMint}
-              </p>
-            )}
+            <p>
+              <strong>Token:</strong> {token}
+              {tokenMint ? ` (${tokenMint})` : ' — not configured'}
+            </p>
           </SectionCard>
 
           <div className="d-grid gap-2 my-4">
@@ -133,7 +145,7 @@ export const StoryView = ({
             <ResultDisplay
               result={txHash}
               title="Redeem Transaction Hash"
-              successMessage="Success! BTC.b → BTC redemption transaction submitted."
+              successMessage={`Success! ${token} → BTC redemption transaction submitted.`}
             />
           )}
           {(error || connectError) && (
@@ -162,13 +174,14 @@ const meta: Meta<typeof StoryView> = {
   parameters: {
     docs: {
       description: {
-        component: `Demonstrates redeeming BTC.b → BTC via the Asset Router's \`redeem_for_btc\` instruction.
+        component: `Demonstrates redeeming BTC.b or LBTC → BTC via the Asset Router's \`redeem_for_btc\` instruction.
 
 **Flow:**
-1. Connect a Solana wallet holding BTC.b tokens
-2. Enter the destination Bitcoin address and amount (in satoshis)
-3. Call \`redeemForBtc\` — burns BTC.b and sends a GMP message through the Mailbox
-4. The Lombard protocol processes the GMP message and sends BTC to the specified address`,
+1. Connect a Solana wallet holding BTC.b or LBTC tokens
+2. Enter the destination Bitcoin address and amount (in BTC)
+3. Optionally set the token mint to the LBTC address to redeem LBTC instead of BTC.b
+4. Call \`redeemForBtc\` — burns the token and sends a GMP message through the Mailbox
+5. The Lombard protocol processes the GMP message and sends BTC to the specified address`,
       },
     },
   },
@@ -176,13 +189,18 @@ const meta: Meta<typeof StoryView> = {
     environment: Env.stage,
     amount: '0.0002',
     btcAddress: '',
-    tokenMint: '',
+    token: 'BTC.b',
   },
   argTypes: {
     environment: {
       control: { type: 'select' },
       options: Object.values(Env),
     },
+    token: {
+      control: { type: 'select' },
+      options: ['BTC.b', 'LBTC'] satisfies RedeemToken[],
+      description: 'Token to redeem for BTC',
+    },
     amount: {
       control: { type: 'text' },
       description: 'Amount to redeem in BTC (e.g. 0.0002)',
@@ -191,10 +209,6 @@ const meta: Meta<typeof StoryView> = {
       control: { type: 'text' },
       description: 'Destination Bitcoin address (taproot, segwit, etc.)',
     },
-    tokenMint: {
-      control: { type: 'text' },
-      description: 'BTC.b mint address override (leave empty for default)',
-    },
   },
 };