@lombard.finance/sdk-solana 1.2.2 → 2.0.0

package/src/web3Sdk/claimToken/shared.ts

@@ -11,7 +11,7 @@ import { sha256 } from 'js-sha256';
 import { IConfig } from '../../const/getConfig';
 import { ISolanaWalletProvider, SolanaNetwork } from '../../types';
 import { sendAndConfirmTransaction } from '../../utils';
-import { parseSignaturesFromProof } from '../claimLBTC/utils/signatureUtils';
+import { parseSignaturesFromProof } from './utils/signatureUtils';
 
 // ── PDA seeds ──
 
@@ -137,83 +137,62 @@ export function getConsortiumSessionPDA(
 }
 
 /**
- * Fetch the current epoch from the on-chain consortium config account.
- *
- * Borsh layout of Consortium Config:
- *   discriminator:   8 bytes  (offset 0)
- *   admin:          32 bytes  (offset 8)
- *   pending_admin:  32 bytes  (offset 40)
- *   current_epoch:   8 bytes  (offset 72, u64 LE)
+ * Fetch the current epoch from the on-chain consortium config account
+ * using Anchor IDL-based deserialization.
  */
 export async function fetchCurrentEpoch(
-  connection: Connection,
+  consortiumProgram: Program,
   consortiumConfigPDA: PublicKey,
 ): Promise<BN> {
-  const accountInfo = await connection.getAccountInfo(consortiumConfigPDA);
-  if (!accountInfo) {
-    throw new Error(
-      `Consortium config account not found at ${consortiumConfigPDA.toBase58()}`,
-    );
-  }
-
-  const EPOCH_OFFSET = 72; // 8 (discriminator) + 32 (admin) + 32 (pending_admin)
-  const MIN_SIZE = EPOCH_OFFSET + 8;
-  if (accountInfo.data.length < MIN_SIZE) {
-    throw new Error(
-      `Consortium config data too short: expected >= ${MIN_SIZE} bytes, got ${accountInfo.data.length}`,
-    );
-  }
-
-  const epochLe = accountInfo.data.readBigUInt64LE(EPOCH_OFFSET);
-  return new BN(epochLe.toString());
+  // Anchor converts all IDL names to camelCase before building the namespace
+  // and decoding accounts, so field access uses camelCase keys.
+  const accountNs = consortiumProgram.account as unknown as Record<
+    string,
+    { fetch: (address: PublicKey) => Promise<unknown> }
+  >;
+  const raw = (await accountNs.config.fetch(consortiumConfigPDA)) as {
+    currentEpoch: BN;
+  };
+  return raw.currentEpoch;
 }
 
-// ── parseAssetRouterConfig ──
+// ── fetchAssetRouterConfig ──
 
 /**
- * Parse Asset Router config from raw account bytes.
- * Equivalent to Go's `getPausedAndBasculeFromConfig(data)`.
+ * Fetch and deserialize Asset Router `Config` account via Anchor IDL.
  *
- * On-chain layout (discriminator 8 bytes, then fields):
- *   admin:              Pubkey  (offset   8, 32 bytes)
- *   pending_admin:      Pubkey  (offset  40, 32 bytes)
- *   treasury:           Pubkey  (offset  72, 32 bytes)
- *   paused:             bool    (offset 104,  1 byte)
- *   native_mint:        Pubkey  (offset 105, 32 bytes)
- *   mailbox:            Pubkey  (offset 137, 32 bytes)
- *   bascule_enabled:    bool    (offset 169,  1 byte)
- *   bascule_program:    Pubkey  (offset 170, 32 bytes)  <- not in IDL
- *   bascule_gmp_program:Pubkey  (offset 202, 32 bytes)  <- not in IDL
- *   ledger_lchain_id:   [u8;32] (offset 234, 32 bytes)
- *   bitcoin_lchain_id:  [u8;32] (offset 266, 32 bytes)
+ * IDL layout (fields used by SDK):
+ *   paused:             bool
+ *   native_mint:        pubkey
+ *   bascule:            Option<pubkey>  (classic bascule for BTC.B)
+ *   bascule_gmp:        Option<pubkey>  (bascule for LBTC GMP)
+ *   ledger_lchain_id:   [u8; 32]
  */
-export function parseAssetRouterConfig(data: Buffer): AssetRouterConfig {
-  // ledger_lchain_id ends at offset 266 — the last field we read
-  const MIN_SIZE = 266;
-  if (data.length < MIN_SIZE) {
-    throw new Error(
-      `Asset Router config account data too short: expected >= ${MIN_SIZE} bytes, got ${data.length}`,
-    );
-  }
-
-  const ZERO_PUBKEY = new PublicKey(new Uint8Array(32));
-
-  const paused = data[104] !== 0;
-  const nativeMint = new PublicKey(data.subarray(105, 137));
-
-  const basculeProgramKey = new PublicKey(data.subarray(170, 202));
-  const basculeProgramId = basculeProgramKey.equals(ZERO_PUBKEY)
-    ? null
-    : basculeProgramKey;
-
-  const basculeGmpProgramKey = new PublicKey(data.subarray(202, 234));
-  const basculeGmpProgramId = basculeGmpProgramKey.equals(ZERO_PUBKEY)
-    ? null
-    : basculeGmpProgramKey;
-
-  const ledgerChainId = new Uint8Array(data.subarray(234, 266));
-
-  return { paused, nativeMint, basculeProgramId, basculeGmpProgramId, ledgerChainId };
+export async function fetchAssetRouterConfig(
+  assetRouterProgram: Program,
+  configPDA: PublicKey,
+): Promise<AssetRouterConfig> {
+  // Anchor camelCases IDL names, so `native_mint` → `nativeMint`,
+  // `bascule_gmp` → `basculeGmp`, `ledger_lchain_id` → `ledgerLchainId`.
+  const accountNs = assetRouterProgram.account as unknown as Record<
+    string,
+    { fetch: (address: PublicKey) => Promise<unknown> }
+  >;
+  const raw = (await accountNs.config.fetch(configPDA)) as {
+    paused: boolean;
+    nativeMint: PublicKey;
+    bascule: PublicKey | null;
+    basculeGmp: PublicKey | null;
+    ledgerLchainId: number[];
+  };
+
+  return {
+    paused: raw.paused,
+    nativeMint: raw.nativeMint,
+    basculeProgramId: raw.bascule ?? null,
+    basculeGmpProgramId: raw.basculeGmp ?? null,
+    ledgerChainId: new Uint8Array(raw.ledgerLchainId),
+  };
 }
 
 // ── Consortium session ──
@@ -255,7 +234,6 @@ export async function executeConsortiumSession(ctx: ClaimContext): Promise<void>
         payer: provider.publicKey,
         config: consortiumConfigPDA,
         session: sessionPDA,
-        validatedPayload: validatedPayloadPDA,
         systemProgram: SystemProgram.programId,
       })
       .transaction();
@@ -265,22 +243,52 @@ export async function executeConsortiumSession(ctx: ClaimContext): Promise<void>
       connection,
       provider,
       debugLabel: 'Consortium create_session',
-      skipPreflight: params.skipPreflight ?? false,
+      skipPreflight: params.skipPreflight ?? true,
     });
     debugLog('create_session completed');
   } else {
     debugLog('Session already exists, skipping create_session');
   }
 
-  // Step 2: post_session_signatures
-  const freshSession =
-    sessionAccount ?? (await connection.getAccountInfo(sessionPDA));
+  // Step 2: post_session_signatures.
+  // Session raw layout: discriminator(8) | signed: Vec<bool> (4 LE len + N bytes) | weight: u64 LE | trailing bytes.
+  // Manual parse: Anchor coder rejects extra trailing bytes that exist in the on-chain account.
   let sessionSigned = false;
-  if (freshSession && freshSession.data.length >= 8 + 8 + 4 + 8) {
-    const vecLen = freshSession.data.readUInt32LE(8 + 8);
-    const weightOffset = 8 + 8 + 4 + vecLen;
-    if (freshSession.data.length >= weightOffset + 8) {
-      sessionSigned = freshSession.data.readBigUInt64LE(weightOffset) > 0n;
+  const freshSessionAccount = sessionAccount
+    ? sessionAccount
+    : await connection.getAccountInfo(sessionPDA);
+  if (freshSessionAccount) {
+    try {
+      const data = freshSessionAccount.data;
+      if (data.length < 20) {
+        throw new Error(`session account too short: ${data.length}`);
+      }
+      const signedLen = data.readUInt32LE(8);
+      const weightOffset = 12 + signedLen;
+      if (data.length < weightOffset + 8) {
+        throw new Error(
+          `session data truncated: need ${weightOffset + 8}, got ${data.length}`,
+        );
+      }
+      const weight = data.readBigUInt64LE(weightOffset);
+      let signedCount = 0;
+      for (let i = 0; i < signedLen; i++) {
+        if (data[12 + i] !== 0) signedCount += 1;
+      }
+      sessionSigned = weight > 0n;
+      debugLog(
+        'Session weight:',
+        weight.toString(),
+        'signed count:',
+        signedCount,
+        'of',
+        signedLen,
+      );
+    } catch (err) {
+      debugLog(
+        'Failed to parse session for signature check:',
+        err instanceof Error ? err.message : String(err),
+      );
     }
   }
 
@@ -309,7 +317,7 @@ export async function executeConsortiumSession(ctx: ClaimContext): Promise<void>
       connection,
       provider,
       debugLabel: 'Consortium post_session_signatures',
-      skipPreflight: params.skipPreflight ?? false,
+      skipPreflight: params.skipPreflight ?? true,
     });
     debugLog('post_session_signatures completed');
   } else {
@@ -334,7 +342,7 @@ export async function executeConsortiumSession(ctx: ClaimContext): Promise<void>
     connection,
     provider,
     debugLabel: 'Consortium finalize_session',
-    skipPreflight: params.skipPreflight ?? false,
+    skipPreflight: params.skipPreflight ?? true,
   });
   debugLog('finalize_session completed — ValidatedPayload created');
 }

package/src/web3Sdk/deposit/deposit.stories.tsx

@@ -0,0 +1,240 @@
+import { Env } from '@lombard.finance/sdk-common';
+import type { Meta, StoryObj } from '@storybook/react';
+import { useState } from 'react';
+
+import { envToNetwork, getConfig } from '../../const/getConfig';
+import {
+  Button,
+  CodeBlock,
+  ConnectButton,
+  ErrorDisplay,
+  ResultDisplay,
+  SectionCard,
+} from '../../stories/components';
+import { functionType } from '../../stories/decorators/function-type';
+import { useConnect } from '../../stories/hooks/useConnect';
+import useQuery from '../../stories/hooks/useQuery';
+import { deposit } from './deposit';
+
+interface DepositStoryArgs {
+  environment: Env;
+  amount: string;
+  recipient: string;
+  sourceTokenMint: string;
+  toLchainId: string;
+  toTokenAddress: string;
+}
+
+export const StoryView = ({
+  environment,
+  amount,
+  recipient,
+  sourceTokenMint,
+  toLchainId,
+  toTokenAddress,
+}: DepositStoryArgs) => {
+  const network = envToNetwork[environment];
+  const config = getConfig(environment);
+  const [transactionLogs, setTransactionLogs] = useState<string[] | null>(null);
+
+  const {
+    data: connectionData,
+    error: connectError,
+    isLoading: isConnecting,
+    connect,
+    disconnect,
+  } = useConnect();
+  const isConnected = !!connectionData;
+  const address = connectionData?.address;
+  const provider = connectionData?.provider;
+
+  const effectiveSource = sourceTokenMint || config.btcbTokenMint;
+  const effectiveToToken = toTokenAddress || config.lbtcTokenMint;
+
+  const request = async () => {
+    if (!provider || !address) throw new Error('Wallet not connected.');
+    if (!recipient)
+      throw new Error('Recipient address is required (set in args).');
+    const parsedAmount = parseFloat(amount);
+    if (!amount || isNaN(parsedAmount) || parsedAmount <= 0)
+      throw new Error('Amount must be a positive number in BTC (set in args).');
+
+    const amountSats = Math.round(parsedAmount * 1e8).toString();
+
+    setTransactionLogs(null);
+    try {
+      const result = await deposit(provider, {
+        amount: amountSats,
+        recipient,
+        sourceTokenMint: sourceTokenMint || undefined,
+        toLchainId: toLchainId || undefined,
+        toTokenAddress: toTokenAddress || undefined,
+        network,
+        env: environment,
+        debug: true,
+      });
+      return result;
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message.includes('Debug logs:')) {
+        const parts = err.message.split('Debug logs:\n');
+        setTransactionLogs(parts[1]?.split('\n') || []);
+      }
+      throw err;
+    }
+  };
+
+  const {
+    data: txHash,
+    error,
+    isLoading,
+    refetch: handleDeposit,
+  } = useQuery(
+    request,
+    [
+      provider,
+      address,
+      amount,
+      recipient,
+      sourceTokenMint,
+      toLchainId,
+      toTokenAddress,
+      environment,
+    ],
+    false,
+  );
+
+  return (
+    <>
+      <ConnectButton
+        connect={connect}
+        disconnect={disconnect}
+        isConnected={isConnected}
+        isLoading={isConnecting}
+        error={connectError}
+        walletName={connectionData?.walletName}
+        address={connectionData?.address}
+        network={network}
+      />
+
+      {isConnected && (
+        <>
+          <SectionCard title="Configuration">
+            <p>
+              <strong>Environment:</strong> {environment}
+            </p>
+            <p>
+              <strong>Network:</strong> {network}
+            </p>
+            <p>
+              <strong>Amount:</strong> {amount} BTC
+            </p>
+            <p>
+              <strong>Recipient:</strong> {recipient || <em>Not set</em>}
+            </p>
+            <p>
+              <strong>Source token (e.g. BTC.b):</strong>{' '}
+              {effectiveSource || <em>Not configured</em>}
+            </p>
+            <p>
+              <strong>Destination token (e.g. LBTC):</strong>{' '}
+              {effectiveToToken || <em>Not configured</em>}
+            </p>
+          </SectionCard>
+
+          <div className="d-grid gap-2 my-4">
+            <Button
+              primary
+              size="large"
+              onClick={handleDeposit}
+              isLoading={isLoading}
+              actionName={deposit.name}
+            />
+          </div>
+
+          {txHash && (
+            <ResultDisplay
+              result={txHash}
+              title="Deposit Transaction Hash"
+              successMessage="Success! Deposit (BTC.b → LBTC) transaction submitted."
+            />
+          )}
+          {(error || connectError) && (
+            <ErrorDisplay
+              error={error || connectError}
+              title="Deposit Error"
+            />
+          )}
+
+          {transactionLogs && transactionLogs.length > 0 && (
+            <SectionCard title="Transaction Logs (Debug)">
+              <CodeBlock text={transactionLogs.join('\n')} />
+            </SectionCard>
+          )}
+        </>
+      )}
+    </>
+  );
+};
+
+const meta: Meta<typeof StoryView> = {
+  title: 'write/deposit (Asset Router)',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [functionType('write')],
+  parameters: {
+    docs: {
+      description: {
+        component: `Demonstrates depositing source token (e.g. BTC.b) for destination token (e.g. LBTC) via the Asset Router's \`deposit\` instruction.
+
+**Flow:**
+1. Connect a Solana wallet holding the source token (default: BTC.b)
+2. Enter the recipient address and amount (in BTC)
+3. Optionally override source mint, destination chain ID, and destination token
+4. Call \`deposit\` — burns the source token and sends a GMP message through the Mailbox
+5. The destination token (e.g. LBTC) is minted to the recipient's ATA for that mint on the target chain (payload carries the token account address)
+
+**Example (devnet):** PROGRAM_ID=LomVyJDZ91jeVbNnTupJXKJTQFakJVMc87CmwDHYt95, MAILBOX=LomJw912MoUd7iiAesTQAgz1paLcTqi6ndG3w3pnKH9`,
+      },
+    },
+  },
+  args: {
+    environment: Env.stage,
+    amount: '0.0002',
+    recipient: '',
+    sourceTokenMint: '',
+    toLchainId: '',
+    toTokenAddress: '',
+  },
+  argTypes: {
+    environment: {
+      control: { type: 'select' },
+      options: Object.values(Env),
+    },
+    amount: {
+      control: { type: 'text' },
+      description: 'Amount to deposit in BTC (e.g. 0.0002)',
+    },
+    recipient: {
+      control: { type: 'text' },
+      description:
+        'Recipient wallet (owner) for the destination token; SDK uses the associated token account in the deposit payload (Solana base58)',
+    },
+    sourceTokenMint: {
+      control: { type: 'text' },
+      description: 'Source token mint override (defaults to BTC.b from config)',
+    },
+    toLchainId: {
+      control: { type: 'text' },
+      description:
+        'Destination Lombard routing chain ID (hex). Defaults to Solana',
+    },
+    toTokenAddress: {
+      control: { type: 'text' },
+      description:
+        'Destination token mint override (defaults to LBTC from config)',
+    },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof meta>;