@lombard.finance/sdk-solana 1.2.2 → 2.0.0

package/src/web3Sdk/redeemToken/redeemForBtc.test.ts

@@ -0,0 +1,306 @@
+import { PublicKey } from '@solana/web3.js';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { IConfig } from '../../const/getConfig';
+import { SolanaNetwork } from '../../types';
+import { ErrorCode, SolanaSdkError } from '../../utils';
+
+// ── Mocks ──
+
+const mockRedeemBtcbForBtc = vi.fn().mockResolvedValue('btcb-sig');
+const mockRedeemLbtcForBtc = vi.fn().mockResolvedValue('lbtc-sig');
+
+vi.mock('./redeemBtcb', () => ({ redeemBtcbForBtc: (...a: unknown[]) => mockRedeemBtcbForBtc(...a) }));
+vi.mock('./redeemLbtc', () => ({ redeemLbtcForBtc: (...a: unknown[]) => mockRedeemLbtcForBtc(...a) }));
+
+const MOCK_LBTC_MINT = 'LBTCojyVJ63rsEED2DLEGWMzSxWJyQynXE91LMLgV1J';
+const MOCK_BTCB_MINT = 'BTCB3ripBAut19jM8kDPVbJHb2ZdR2GcZvGZkCmFPtV8';
+const MOCK_ASSET_ROUTER = 'LomVyJDZ91jeVbNnTupJXKJTQFakJVMc87CmwDHYt95';
+const MOCK_MAILBOX = 'LomJw912MoUd7iiAesTQAgz1paLcTqi6ndG3w3pnKH9';
+const MOCK_SOLANA_CHAIN_ID = '0259db5080fc2c6d3bcf7ca90712d3c2e5e6c28f27f0dfbb9953bdb0894c03ab';
+const MOCK_BITCOIN_CHAIN_ID = 'ff000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6';
+const MOCK_LEDGER_CHAIN_ID = '031f51c4e4cc1dae1c752d2f8fe2ae045da668a13f2e47a465964d630f5ed22e';
+const MOCK_PAYER = '8yarEiDaJVikHZbk3PQSoWiDn2T3oM1FHZN1Jv4VZFdr';
+
+const fullConfig: IConfig = {
+  lbtcTokenMint: MOCK_LBTC_MINT,
+  btcbTokenMint: MOCK_BTCB_MINT,
+  assetRouter: MOCK_ASSET_ROUTER,
+  mailbox: MOCK_MAILBOX,
+  solanaRoutingChainId: MOCK_SOLANA_CHAIN_ID,
+  bitcoinRoutingChainId: MOCK_BITCOIN_CHAIN_ID,
+  ledgerChainId: MOCK_LEDGER_CHAIN_ID,
+  lbtcProgramId: 'HEY7PCJe3GB27UWdopuYb1xDbB5SNtTcYPxRjntvfBSA',
+  treasuryAddress: 'ByHNGi4zPJw5StyWZoLQJ9n2wT12oupJF2pTSNKMnnAZ',
+  bascule: null,
+  basculeData: null,
+  admin: '6MKjyWZnkSMitJYAixvJzqhJiVsjTA3hYHX8aP9qNioj',
+  lzOftAdapter: 'AEFwQgaSNhQcZhAcGZGM9iTyGML3fsJC2aBvYmzV81FE',
+  lzOftStore: '3SG3oyrG3KSvJ9bbxPDu7ZXEe5o1TW1QkgudkKvK6FK4',
+  lzMultisig: 'GfYV1f1bR9vy41mSyQ8quxYbds121kijSBj5A3nG8oDQ',
+  lzEscrow: 'GRq2yasTvWWPPqSwxCZvqfCTfDhP3MswDH4nW2v6F5To',
+  consortium: null,
+  ratioOracle: null,
+  bridge: null,
+  lombardTokenPool: null,
+};
+
+vi.mock('../../const/getConfig', () => ({
+  DEFAULT_ENV: 'dev' as const,
+  networkToEnv: { devnet: 'dev', testnet: 'testnet', 'mainnet-beta': 'prod' },
+  getConfig: vi.fn(() => fullConfig),
+}));
+
+vi.mock('../../const/rpcUrls', () => ({
+  getConnection: vi.fn(() => mockConnection),
+}));
+
+vi.mock('@lombard.finance/sdk-common', () => ({
+  getOutputScript: vi.fn().mockResolvedValue('0x001234abcd'),
+}));
+
+vi.mock('../../utils/tokenAccount', () => ({
+  getTokenProgramForMint: vi.fn().mockResolvedValue(new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')),
+}));
+
+vi.mock('../../idl/getAssetRouterIdl', () => ({
+  getAssetRouterIdl: vi.fn(() => ({
+    address: MOCK_ASSET_ROUTER,
+    metadata: { name: 'asset_router', version: '0.1.0', spec: '0.1.0' },
+    instructions: [],
+  })),
+}));
+
+// Mock Program constructor — needed by redeemForBtc to create assetRouterProgram
+vi.mock('@coral-xyz/anchor', () => ({
+  Program: vi.fn().mockImplementation(() => ({})),
+}));
+
+// Build AR config data: 8 (disc) + 32 (admin) + 32 (pending_admin) + 32 (treasury) + 1 (paused=0)
+function buildArConfigData(paused = false) {
+  const data = Buffer.alloc(105, 0);
+  const treasury = new PublicKey('8yarEiDaJVikHZbk3PQSoWiDn2T3oM1FHZN1Jv4VZFdr');
+  treasury.toBuffer().copy(data, 72);
+  data[104] = paused ? 1 : 0;
+  return data;
+}
+
+// Build mailbox config data: 8 (disc) + 32 (admin) + 32 (pending_admin) + 32 (treasury) = 104
+function buildMailboxConfigData() {
+  const data = Buffer.alloc(104, 0);
+  const treasury = new PublicKey('8yarEiDaJVikHZbk3PQSoWiDn2T3oM1FHZN1Jv4VZFdr');
+  treasury.toBuffer().copy(data, 72);
+  return data;
+}
+
+const mockConnection = {
+  getAccountInfo: vi.fn().mockImplementation((pubkey: PublicKey) => {
+    const key = pubkey.toBase58();
+    const [arPDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('asset_router_config')],
+      new PublicKey(MOCK_ASSET_ROUTER),
+    );
+    if (key === arPDA.toBase58()) {
+      return Promise.resolve({ data: buildArConfigData() });
+    }
+    return Promise.resolve({ data: buildMailboxConfigData() });
+  }),
+};
+
+const mockProvider = { publicKey: MOCK_PAYER };
+
+const baseParams = {
+  amount: '100000',
+  btcAddress: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+  network: SolanaNetwork.devnet,
+  tokenMint: MOCK_BTCB_MINT,
+};
+
+describe('redeemForBtc', () => {
+  let redeemForBtcFn: typeof import('./redeemForBtc').redeemForBtc;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+
+    // Re-establish default mock implementations cleared by previous tests
+    mockConnection.getAccountInfo.mockImplementation((pubkey: PublicKey) => {
+      const [arPDA] = PublicKey.findProgramAddressSync(
+        [Buffer.from('asset_router_config')],
+        new PublicKey(MOCK_ASSET_ROUTER),
+      );
+      if (pubkey.toBase58() === arPDA.toBase58()) {
+        return Promise.resolve({ data: buildArConfigData() });
+      }
+      return Promise.resolve({ data: buildMailboxConfigData() });
+    });
+
+    const mod = await import('./redeemForBtc');
+    redeemForBtcFn = mod.redeemForBtc;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ── Validation ──
+
+  it('should throw when wallet is not connected', async () => {
+    const noWalletProvider = { publicKey: null };
+
+    await expect(
+      redeemForBtcFn(noWalletProvider as any, baseParams),
+    ).rejects.toThrow('Wallet not connected');
+  });
+
+  it('should throw when Asset Router is not configured', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, assetRouter: null });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow('Asset Router not configured');
+  });
+
+  it('should throw when Mailbox is not configured', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, mailbox: null });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow('Mailbox not configured');
+  });
+
+  it('should throw when Solana routing chain ID is not configured', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, solanaRoutingChainId: null });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow('Solana routing chain ID not configured');
+  });
+
+  it('should throw when Bitcoin routing chain ID is not configured', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, bitcoinRoutingChainId: null });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow('Bitcoin routing chain ID not configured');
+  });
+
+  it('should throw when tokenMint is BTC.b but env has no BTC.b mint configured', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, btcbTokenMint: null });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow(/Unsupported tokenMint for redeemForBtc/);
+  });
+
+  it('should throw when tokenMint override is not LBTC or BTC.b for the network', async () => {
+    const foreignMint = 'So11111111111111111111111111111111111111112';
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, {
+        ...baseParams,
+        tokenMint: foreignMint,
+      }),
+    ).rejects.toThrow(/Unsupported tokenMint for redeemForBtc/);
+
+    expect(mockRedeemBtcbForBtc).not.toHaveBeenCalled();
+    expect(mockRedeemLbtcForBtc).not.toHaveBeenCalled();
+  });
+
+  it('should throw when amount is invalid', async () => {
+    await expect(
+      redeemForBtcFn(mockProvider as any, { ...baseParams, amount: '0' }),
+    ).rejects.toThrow('greater than zero');
+  });
+
+  it('should throw when Asset Router is paused', async () => {
+    const arPDA = PublicKey.findProgramAddressSync(
+      [Buffer.from('asset_router_config')],
+      new PublicKey(MOCK_ASSET_ROUTER),
+    )[0];
+
+    mockConnection.getAccountInfo.mockImplementation((pubkey: PublicKey) => {
+      if (pubkey.toBase58() === arPDA.toBase58()) {
+        return Promise.resolve({ data: buildArConfigData(true) });
+      }
+      return Promise.resolve({ data: buildMailboxConfigData() });
+    });
+
+    await expect(
+      redeemForBtcFn(mockProvider as any, baseParams),
+    ).rejects.toThrow('Asset Router is paused');
+  });
+
+  // ── Routing ──
+
+  it('should route to redeemBtcbForBtc when tokenMint is the configured BTC.b mint', async () => {
+    await redeemForBtcFn(mockProvider as any, baseParams);
+
+    expect(mockRedeemBtcbForBtc).toHaveBeenCalledTimes(1);
+    expect(mockRedeemLbtcForBtc).not.toHaveBeenCalled();
+  });
+
+  it('should route to redeemLbtcForBtc when tokenMint equals LBTC mint', async () => {
+    await redeemForBtcFn(mockProvider as any, {
+      ...baseParams,
+      tokenMint: MOCK_LBTC_MINT,
+    });
+
+    expect(mockRedeemLbtcForBtc).toHaveBeenCalledTimes(1);
+    expect(mockRedeemBtcbForBtc).not.toHaveBeenCalled();
+  });
+
+  it('should route to redeemBtcbForBtc when tokenMint is explicitly BTC.b', async () => {
+    await redeemForBtcFn(mockProvider as any, {
+      ...baseParams,
+      tokenMint: MOCK_BTCB_MINT,
+    });
+
+    expect(mockRedeemBtcbForBtc).toHaveBeenCalledTimes(1);
+    expect(mockRedeemLbtcForBtc).not.toHaveBeenCalled();
+  });
+
+  it('should pass correct RedeemContext to sub-flow', async () => {
+    await redeemForBtcFn(mockProvider as any, baseParams);
+
+    const ctx = mockRedeemBtcbForBtc.mock.calls[0][0];
+    expect(ctx.payer).toEqual(new PublicKey(MOCK_PAYER));
+    expect(ctx.mint).toEqual(new PublicKey(MOCK_BTCB_MINT));
+    expect(ctx.assetRouterProgramId).toEqual(new PublicKey(MOCK_ASSET_ROUTER));
+    expect(ctx.mailboxProgramId).toEqual(new PublicKey(MOCK_MAILBOX));
+    expect(ctx.env).toBe('dev');
+    expect(ctx.config).toBe(fullConfig);
+    expect(ctx.scriptPubKey).toBeInstanceOf(Buffer);
+    expect(ctx.scriptPubKey.length).toBeGreaterThan(0);
+  });
+
+  // ── Error wrapping ──
+
+  it('should wrap errors with SolanaSdkError', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+    vi.mocked(getConfig).mockReturnValueOnce({ ...fullConfig, assetRouter: null });
+
+    try {
+      await redeemForBtcFn(mockProvider as any, baseParams);
+      expect.unreachable('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(SolanaSdkError);
+      expect((err as SolanaSdkError).code).toBe(ErrorCode.REDEEM_REJECTED);
+    }
+  });
+
+  it('should use env override when provided', async () => {
+    const { getConfig } = await import('../../const/getConfig');
+
+    await redeemForBtcFn(mockProvider as any, {
+      ...baseParams,
+      env: 'stage',
+    });
+
+    expect(getConfig).toHaveBeenCalledWith('stage');
+  });
+});

package/src/web3Sdk/redeemToken/redeemForBtc.ts

@@ -1,76 +1,35 @@
-import { BN, Program } from '@coral-xyz/anchor';
-import { Env, getOutputScript } from '@lombard.finance/sdk-common';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  getAssociatedTokenAddress,
-} from '@solana/spl-token';
-import { PublicKey, SystemProgram } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+import { getOutputScript } from '@lombard.finance/sdk-common';
+import { PublicKey } 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 { ISolanaWalletProvider } from '../../types';
 import {
   ErrorCode,
-  sendAndConfirmTransaction,
   SolanaSdkError,
 } from '../../utils';
 import { createDebugLogger } from '../../utils/createDebugLogger';
 import { getTokenProgramForMint } from '../../utils/tokenAccount';
+import { redeemBtcbForBtc } from './redeemBtcb';
+import { redeemLbtcForBtc } from './redeemLbtc';
+import { RedeemContext, RedeemForBtcParams, validateAmount } from './shared';
 
-/**
- * BTC native token address in Lombard protocol (to_token_address for BTC in token_route PDA).
- * BTC is represented as 0x...01 (32 bytes, value 1).
- */
-const BTC_NATIVE_TOKEN_ADDRESS = (() => {
-  const buf = Buffer.alloc(32, 0);
-  buf[31] = 1;
-  return buf;
-})();
-
-export interface RedeemForBtcParams {
-  amount: string;
-  btcAddress: string;
-  /**
-   * BTC.b mint address override. Defaults to config.btcbTokenMint.
-   */
-  tokenMint?: string;
-  network: SolanaNetwork;
-  /**
-   * Optional environment override. When provided, used instead of
-   * the default `networkToEnv[network]` mapping to resolve config.
-   * Useful when multiple environments share the same Solana network
-   * (e.g. both 'dev' and 'stage' use devnet).
-   */
-  env?: Env;
-  rpcUrl?: string;
-  debug?: boolean;
-  /**
-   * Skip preflight transaction simulation before broadcast.
-   *
-   * Defaults to `false` (simulation enabled). Set to `true` if preflight
-   * simulation gives false negatives — for example, when the simulation node
-   * has not yet seen the latest global nonce for the `outbound_message` PDA,
-   * leading to a spurious `ConstraintSeeds (0x7d6)` failure even though the
-   * transaction would land correctly on-chain. The retry loop inside
-   * `redeemForBtc` already handles the `0x7d6` error returned by
-   * `confirmTransaction`, so enabling preflight only adds a redundant check
-   * at the cost of potential false negatives on lagging RPC nodes.
-   */
-  skipPreflight?: boolean;
-}
+export type { RedeemForBtcParams } from './shared';
 
 /**
- * Redeem BTC.b → BTC on Solana via Asset Router's `redeem_for_btc`.
+ * Redeem tokens (BTC.b or LBTC) → BTC on Solana via Asset Router.
  *
- * Burns BTC.b tokens and sends a GMP message through the Mailbox to trigger
- * a BTC payout to the specified Bitcoin address.
+ * Routes to the appropriate flow based on the token mint:
+ * - BTC.b mint → burns BTC.b via `redeem_for_btc`
+ * - LBTC mint → burns LBTC via LBTC-specific redemption flow
  */
 export async function redeemForBtc(
   provider: ISolanaWalletProvider,
   params: RedeemForBtcParams,
 ): Promise<string> {
-  const { amount, btcAddress, network, env: envOverride, rpcUrl, debug = false, skipPreflight = false } = params;
+  const { amount, btcAddress, network, env: envOverride, rpcUrl, debug = false } = params;
   const { debugLog, printLogs } = createDebugLogger({ debug });
 
   try {
@@ -94,28 +53,18 @@ export async function redeemForBtc(
       throw new Error(`Bitcoin routing chain ID not configured for network: ${network}`);
     }
 
-    const mintAddress = params.tokenMint || config.btcbTokenMint;
-    if (!mintAddress) {
-      throw new Error(`BTC.b mint not configured for network: ${network}`);
-    }
-
-    // Validate amount: must be a non-zero positive integer within u64 range
-    const U64_MAX = 18446744073709551615n;
-    if (!/^\d+$/.test(amount)) {
-      throw new Error(
-        `Invalid amount "${amount}": must be a positive integer string (lamports, no decimals or signs)`,
-      );
-    }
-    const parsedAmount = BigInt(amount);
-    if (parsedAmount === 0n) {
-      throw new Error('Amount must be greater than zero');
-    }
-    if (parsedAmount > U64_MAX) {
+    const mintAddress = params.tokenMint;
+    const supportedMints = [config.lbtcTokenMint, config.btcbTokenMint].filter(
+      (m): m is string => m != null,
+    );
+    if (!supportedMints.includes(mintAddress)) {
       throw new Error(
-        `Amount ${amount} exceeds the u64 maximum (${U64_MAX})`,
+        `Unsupported tokenMint for redeemForBtc: ${mintAddress}. Use the configured LBTC or BTC.b mint for network: ${network}.`,
       );
     }
 
+    validateAmount(amount);
+
     const connection = getConnection(network, rpcUrl);
     const payer = new PublicKey(provider.publicKey);
     const mint = new PublicKey(mintAddress);
@@ -140,56 +89,20 @@ export async function redeemForBtc(
     const tokenProgramId = await getTokenProgramForMint(connection, mint);
     debugLog('Token program:', tokenProgramId.toBase58());
 
-    // ── Asset Router PDAs ──
+    // ── Asset Router config PDA ──
     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(),
-        bitcoinRoutingChainId,
-        BTC_NATIVE_TOKEN_ADDRESS,
-      ],
-      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 ──
+    // ── Mailbox config PDA ──
     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('Asset Router config PDA:', assetRouterConfigPDA.toBase58());
     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([
@@ -230,124 +143,50 @@ export async function redeemForBtc(
     );
     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,
-    );
-
-    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);
-    if (userBalance < parsedAmount) {
-      throw new Error(
-        `Insufficient BTC.b balance: have ${tokenBalance.value.uiAmountString}, need ${Number(parsedAmount) / 1e8}`,
-      );
-    }
-
     const assetRouterProgram = new Program(
       getAssetRouterIdl(env),
       { connection },
     );
 
-    // ── 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++) {
-      // Read fresh nonce right before building the tx
-      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,
-        });
+    const ctx: RedeemContext = {
+      provider,
+      params,
+      env,
+      config,
+      connection,
+      payer,
+      mint,
+      tokenProgramId,
+      scriptPubKey,
+      assetRouterProgramId,
+      mailboxProgramId,
+      solanaRoutingChainId,
+      bitcoinRoutingChainId,
+      assetRouterProgram,
+      assetRouterConfigPDA,
+      mailboxConfigPDA,
+      arTreasury,
+      mailboxTreasury,
+      debugLog,
+    };
 
-        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;
-      }
+    // Route based on token mint
+    const isLbtc = mintAddress === config.lbtcTokenMint;
+    if (isLbtc) {
+      debugLog('Flow: LBTC → BTC redemption');
+      return await redeemLbtcForBtc(ctx);
     }
 
-    throw new Error('Failed after max nonce retries');
+    debugLog('Flow: BTC.b → BTC redemption');
+    return await redeemBtcbForBtc(ctx);
   } catch (error: unknown) {
     if (error instanceof Error && debug) {
       error.message = `${error.message}\n\nDebug logs:\n${printLogs()}`;
     }
     throw SolanaSdkError.wrap(
       error,
-      ErrorCode.UNSTAKE_REJECTED,
-      'BTC.b redeem_for_btc operation failed',
+      ErrorCode.REDEEM_REJECTED,
+      'redeem_for_btc operation failed',
     );
   }
 }