@wireio/stake 1.1.0 → 2.1.0

package/src/networks/solana/solana.ts

@@ -4,20 +4,28 @@ import {
     Connection,
     ConnectionConfig,
     PerfSample,
+    SendTransactionError,
     PublicKey as SolPubKey,
     SystemProgram,
     Transaction,
+    TransactionInstruction,
+    TransactionMessage,
     TransactionSignature,
+    VersionedTransaction,
 } from '@solana/web3.js';
 import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
 import {
     ASSOCIATED_TOKEN_PROGRAM_ID,
+    createAssociatedTokenAccountInstruction,
     getAssociatedTokenAddressSync,
     TOKEN_2022_PROGRAM_ID,
 } from '@solana/spl-token';
 
+import * as multisig from "@sqds/multisig";
+
 import {
+    Base58,
     ChainID,
     ExternalNetwork,
     KeyType,
@@ -28,6 +36,7 @@ import {
 import {
     IStakingClient,
     Portfolio,
+    SquadsXConfig,
     StakerConfig,
     TrancheSnapshot,
 } from '../../types';
@@ -39,10 +48,7 @@ import { OutpostClient } from './clients/outpost.client';
 import { TokenClient } from './clients/token.client';
 
 import {
-    deriveLiqsolMintPda,
-    deriveReservePoolPda,
-    deriveStakeMetricsPda,
-    deriveVaultPda,
+    DEFAULT_AVERAGE_PAY_RATE,
     INDEX_SCALE,
     PAY_RATE_SCALE_FACTOR,
 } from './constants';
@@ -50,6 +56,7 @@ import {
 import { buildSolanaTrancheSnapshot, ceilDiv } from './utils';
 import { GlobalConfig, PayRateEntry, SolanaTransaction } from './types';
 import { SolanaProgramService } from './program';
+import bs58 from 'bs58';
 
 const commitment: Commitment = 'confirmed';
 
@@ -78,6 +85,9 @@ export class SolanaStakingClient implements IStakingClient {
     public tokenClient: TokenClient;
     public program: SolanaProgramService
 
+    private smartAccount?: SolPubKey; // PDA (off-curve)
+    private signer?: SolPubKey;       // on-curve signer
+
     get solPubKey(): SolPubKey {
         if (!this.pubKey) throw new Error('pubKey is undefined');
         return new SolPubKey(this.pubKey.data.array);
@@ -87,6 +97,18 @@ export class SolanaStakingClient implements IStakingClient {
         return this.config.network;
     }
 
+    get feePayer(): SolPubKey {
+        if (this.signer) return this.signer;
+        // fallback for normal wallets
+        if (this.anchor.wallet.publicKey) return this.anchor.wallet.publicKey;
+        throw new Error('No signing authority available');
+    }
+
+    get squadsX(): SquadsXConfig | null {
+        const config = this.config.extras?.squadsX;
+        return config ?? null;
+    }
+
     constructor(private config: StakerConfig) {
         const adapter = config.provider as BaseSignerWalletAdapter | undefined;
 
@@ -185,18 +207,95 @@ export class SolanaStakingClient implements IStakingClient {
             commitment,
         });
 
-        this.depositClient = new DepositClient(this.anchor);
-        this.distributionClient = new DistributionClient(this.anchor);
-        this.leaderboardClient = new LeaderboardClient(this.anchor);
-        this.outpostClient = new OutpostClient(this.anchor);
-        this.tokenClient = new TokenClient(this.anchor);
-        this.program = new SolanaProgramService(this.anchor);
+        this.program = new SolanaProgramService(this.anchor, config.network.chainId as SolChainID);
+
+        this.depositClient = new DepositClient(this.anchor, this.program);
+        this.distributionClient = new DistributionClient(this.anchor, this.program);
+        this.leaderboardClient = new LeaderboardClient(this.anchor, this.program);
+        this.outpostClient = new OutpostClient(this.anchor, this.program);
+        this.tokenClient = new TokenClient(this.anchor, this.program);
     }
 
     // ---------------------------------------------------------------------
     // IStakingClient core methods
     // ---------------------------------------------------------------------
 
+
+    async createVaultLiqsolAtaOneShot(params: {
+        connection: Connection;
+        payer: SolPubKey;      // user's wallet pubkey (signer)
+        vaultPda: SolPubKey;   // squads vault PDA (off-curve owner)
+    }): Promise<{ tx: Transaction; vaultAta: SolPubKey } | null> {
+        const { connection, payer, vaultPda } = params;
+
+        const liqsolMint = this.program.deriveLiqsolMintPda();
+
+        const vaultAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            vaultPda,
+            true, // allowOwnerOffCurve
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+
+        // If it already exists, just no-op
+        const info = await connection.getAccountInfo(vaultAta, "confirmed");
+
+        if (info) return null;
+
+        const ix = createAssociatedTokenAccountInstruction(
+            payer,      // payer = user
+            vaultAta,   // ata address
+            vaultPda,   // owner = vault
+            liqsolMint,
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+
+        const tx = new Transaction().add(ix);
+        return { tx, vaultAta };
+    }
+
+    private async prepSquadsIxs(ix: TransactionInstruction): Promise<TransactionInstruction[]> {
+        if (!this.squadsX) throw new Error('Attempting to wrap Squads instruction without SquadsX config');
+
+        const multisigPda = this.squadsMultisigPDA!;
+        const vaultPda = this.squadsVaultPDA!;
+        const vaultIndex = this.squadsX?.vaultIndex ?? 0;
+        const creator = this.solPubKey;
+
+        // compute next transactionIndex 
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(this.connection, multisigPda);
+        const current = BigInt(ms.transactionIndex?.toString() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        // inner message uses vault as payer
+        // const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 });
+        const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+        const transactionMessage = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [ix],
+        });
+
+        const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+            multisigPda,
+            transactionIndex,
+            creator,
+            vaultIndex,
+            transactionMessage,
+            ephemeralSigners: 0,
+        });
+
+        const createProposalIx = await multisig.instructions.proposalCreate({
+            multisigPda,
+            transactionIndex,
+            creator,
+        });
+
+        return [createVaultTxIx, createProposalIx];
+    }
+
     /**
      * Deposit native SOL into liqSOL (liqsol_core::deposit).
      * Handles tx build, sign, send, and confirmation.
@@ -208,20 +307,54 @@ export class SolanaStakingClient implements IStakingClient {
         }
 
         try {
-            // Build compute budget increase instruction
             const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-
-            // Build the Outpost synd instruction
-            const ix = await this.depositClient.buildDepositTx(amountLamports);
-
-            // Wrap in a transaction and send
-            const tx = new Transaction().add(cuIx, ix);
+            // console.log('amountLamports', amountLamports);
+
+            // if (!!this.squadsX) {
+
+            //     const createVaultTx = await this.createVaultLiqsolAtaOneShot({
+            //         connection: this.connection,
+            //         payer: this.solPubKey,
+            //         vaultPda: this.squadsVaultPDA!,
+            //     })
+
+            //     if (createVaultTx !== null) {
+            //         // console.log('need to create vault ata first...');
+            //         const tx0 = new Transaction().add(createVaultTx.tx);
+            //         const prepared0 = await this.prepareTx(tx0);
+            //         const signed0 = await this.signTransaction(prepared0.tx);
+            //         const sent0 = await this.sendAndConfirmHttp(signed0, prepared0);
+            //         // console.log('create Vault ATA', sent0);
+            //     }
+
+            //     const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA!)
+            //     const squadIxs = await this.prepSquadsIxs(ix)
+
+            //     const tx1 = new Transaction().add(cuIx, squadIxs[0]);
+            //     const prepared1 = await this.prepareTx(tx1);
+            //     const signed1 = await this.signTransaction(prepared1.tx);
+            //     const sent1 = await this.sendAndConfirmHttp(signed1, prepared1);
+            //     console.log('SENT 1', sent1);
+
+            //     const tx2 = new Transaction().add(cuIx, squadIxs[1]);
+            //     const prepared2 = await this.prepareTx(tx2);
+            //     const signed2 = await this.signTransaction(prepared2.tx);
+            //     const sent2 = await this.sendAndConfirmHttp(signed2, prepared2);
+            //     console.log('SENT 2', sent2);
+
+            //     return sent2;
+            // }
+            // else {
+            const ix = await this.depositClient.buildDepositTx(amountLamports)
+            const tx = new Transaction().add(ix);
             const prepared = await this.prepareTx(tx);
             const signed = await this.signTransaction(prepared.tx);
 
             return this.sendAndConfirmHttp(signed, prepared);
+            // }
         } catch (err) {
-            throw new Error(`Failed to deposit Solana: ${err}`);
+            console.log(`Failed to deposit Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -255,7 +388,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to withdraw Solana: ${err}`);
+            console.log(`Failed to withdraw Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -285,7 +419,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to stake Solana: ${err}`);
+            console.log(`Failed to stake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -316,7 +451,8 @@ export class SolanaStakingClient implements IStakingClient {
             return this.sendAndConfirmHttp(signed, prepared);
         }
         catch (err) {
-            throw new Error(`Failed to unstake Solana: ${err}`);
+            console.log(`Failed to unstake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -344,7 +480,8 @@ export class SolanaStakingClient implements IStakingClient {
             return this.sendAndConfirmHttp(signed, prepared);
         }
         catch (err) {
-            throw new Error(`Failed to buy liqSOL pretokens: ${err}`);
+            console.log(`Failed to buy liqSOL pretokens: ${err}`);
+            throw err;
         }
     }
 
@@ -361,16 +498,16 @@ export class SolanaStakingClient implements IStakingClient {
         if (!this.pubKey) throw new Error('User pubKey is undefined');
 
         try {
-            const user = this.solPubKey;
+            const user = !!this.squadsX ? this.squadsVaultPDA! : this.solPubKey;
 
-            const reservePoolPDA = deriveReservePoolPda();
-            const vaultPDA = deriveVaultPda();
-            const liqsolMint = deriveLiqsolMintPda();
+            const reservePoolPDA = this.program.deriveReservePoolPda();
+            const vaultPDA = this.program.deriveVaultPda();
+            const liqsolMint = this.program.deriveLiqsolMintPda();
 
             const userLiqsolAta = getAssociatedTokenAddressSync(
                 liqsolMint,
                 user,
-                false,
+                true,   //set to true to allow off curve (e.g. PDA for squadsx wallet)
                 TOKEN_2022_PROGRAM_ID,
                 ASSOCIATED_TOKEN_PROGRAM_ID,
             );
@@ -497,7 +634,8 @@ export class SolanaStakingClient implements IStakingClient {
             };
         }
         catch (err) {
-            throw new Error(`Failed to get Solana portfolio: ${err}`);
+            console.log(`Failed to get Solana portfolio: ${err}`);
+            throw err;
         }
     }
 
@@ -510,6 +648,21 @@ export class SolanaStakingClient implements IStakingClient {
         return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
+    // ---------------------------------------------------------------------
+    // SquadsX Helpers
+    // ---------------------------------------------------------------------
+
+    get squadsMultisigPDA(): SolPubKey | null {
+        if (!this.squadsX) return null;
+        return new SolPubKey(this.squadsX.multisigPDA);
+    }
+    get squadsVaultPDA(): SolPubKey | null {
+        if (!this.squadsX || !this.squadsMultisigPDA) return null;
+        const multisigPda = this.squadsMultisigPDA;
+        const index = this.squadsX.vaultIndex ?? 0;
+        const pda = multisig.getVaultPda({ multisigPda, index });
+        return pda[0];
+    }
 
     // ---------------------------------------------------------------------
     // READ-ONLY Public Methods
@@ -525,18 +678,8 @@ export class SolanaStakingClient implements IStakingClient {
      *
      * This is READ-ONLY and works even with no connected wallet.
      */
-    async getTrancheSnapshot(options?: {
-        chainID?: ChainID;
-        windowBefore?: number;
-        windowAfter?: number;
-    }): Promise<TrancheSnapshot> {
+    async getTrancheSnapshot(chainID: ChainID): Promise<TrancheSnapshot> {
         try {
-            const {
-                chainID = SolChainID.WireTestnet,
-                windowBefore,
-                windowAfter,
-            } = options ?? {};
-
             const [globalState, trancheState] = await Promise.all([
                 this.tokenClient.fetchGlobalState(),
                 this.tokenClient.fetchTrancheState(),
@@ -551,12 +694,11 @@ export class SolanaStakingClient implements IStakingClient {
                 trancheState,
                 solPriceUsd,
                 nativePriceTimestamp: timestamp,
-                ladderWindowBefore: windowBefore,
-                ladderWindowAfter: windowAfter,
             });
         }
         catch (err) {
-            throw new Error(`Failed to build Solana tranche snapshot: ${err}`);
+            console.log(`Failed to build Solana tranche snapshot: ${err}`);
+            throw err;
         }
     }
 
@@ -578,7 +720,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return apyPercent;
         } catch (err) {
-            throw new Error(`Failed to compute Solana system APY: ${err}`);
+            console.log(`Failed to compute Solana system APY: ${err}`);
+            throw err;
         }
     }
 
@@ -588,24 +731,27 @@ export class SolanaStakingClient implements IStakingClient {
      * de-scaled using PAY_RATE_SCALE_FACTOR (1e12).
      */
     private async getEpochRateDecimalFromProgram(): Promise<number> {
-        try {
-
-            const liqSolCoreProgram = this.program.getProgram('liqsolCore');
-            const stakeMetricsPda = deriveStakeMetricsPda();
-            const stakeMetrics =
-                await liqSolCoreProgram.account.stakeMetrics.fetch(stakeMetricsPda);
+        const liqSolCoreProgram = this.program.getProgram('liqsolCore');
+        const payRateHistoryPda = this.program.derivePayRateHistoryPda();
 
-            // solSystemPayRate is stored on-chain with PAY_RATE_SCALE_FACTOR (1e12)
-            const raw = BigInt(stakeMetrics.solSystemPayRate.toString());
+        const payRateHistory =
+            await liqSolCoreProgram.account.payRateHistory.fetch(payRateHistoryPda);
 
-            // Convert to JS number in **decimal per epoch** units
-            const rateDecimal = Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
+        const totalEntriesAdded = Number(payRateHistory.totalEntriesAdded);
+        const maxEntries = Number(payRateHistory.maxEntries);
 
-            return rateDecimal;
-        }
-        catch (err) {
-            throw new Error(`Failed to read stakeMetrics from program: ${err}`);
+        if (totalEntriesAdded === 0) {
+            // No real entries yet, fall back to default
+            return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
         }
+
+        // Latest entry is at (currentIndex - 1 + maxEntries) % maxEntries
+        const currentIndex = Number(payRateHistory.currentIndex);
+        const latestIdx = (currentIndex - 1 + maxEntries) % maxEntries;
+        const latestEntry = payRateHistory.entries[latestIdx];
+
+        const raw = BigInt(latestEntry.scaledRate.toString());
+        return Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
     }
 
     // Simple cache so we don’t hammer RPC
@@ -690,7 +836,7 @@ export class SolanaStakingClient implements IStakingClient {
             return BigInt(0);
         }
 
-        const [avgPayRate, globalConfig]: [BN, GlobalConfig] = await Promise.all([
+        const [avgPayRate, globalConfig]: [BN, GlobalConfig | null] = await Promise.all([
             this.distributionClient.getAverageScaledPayRate(windowSize),
             this.distributionClient.getGlobalConfig(),
         ]);
@@ -741,14 +887,12 @@ export class SolanaStakingClient implements IStakingClient {
     }): Promise<bigint> {
         this.ensureUser();
 
-        const payer = this.solPubKey;
-
         // -------------------------------------------------------------
         // 1) Current wallet balance (prefer caller override)
         // -------------------------------------------------------------
         const balanceLamports: bigint =
             options?.balanceOverrideLamports ??
-            BigInt(await this.connection.getBalance(payer, commitment));
+            BigInt(await this.connection.getBalance(this.feePayer, commitment));
 
         if (balanceLamports <= BigInt(0)) {
             return BigInt(0);
@@ -859,7 +1003,7 @@ export class SolanaStakingClient implements IStakingClient {
             return this.cachedTxFee.value;
         }
 
-        const payer = this.solPubKey;
+        const payer = this.feePayer;
 
         const dummyIx = SystemProgram.transfer({
             fromPubkey: payer,
@@ -892,38 +1036,107 @@ export class SolanaStakingClient implements IStakingClient {
     /**
      * Send a signed transaction over HTTP RPC and wait for confirmation.
      * Throws if the transaction fails.
+     *
+     * - Handles benign "already processed" preflight errors.
+     * - Uses getSignatureStatuses() instead of confirmTransaction()
+     *   so we don't care about blockheight expiry.
      */
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
-        ctx: { blockhash: string; lastValidBlockHeight: number },
+        _ctx: { blockhash: string; lastValidBlockHeight: number },
     ): Promise<string> {
         this.ensureUser();
 
-        const signature = await this.connection.sendRawTransaction(
-            signed.serialize(),
-            {
+        const rawTx = signed.serialize();
+        let signature: string;
+
+        // -------------------------------------------------------------
+        // 1) Send the raw transaction
+        //    Handle "already been processed" as a soft success.
+        // -------------------------------------------------------------
+        try {
+            signature = await this.connection.sendRawTransaction(rawTx, {
                 skipPreflight: false,
                 preflightCommitment: commitment,
                 maxRetries: 3,
-            },
-        );
+            });
+        } catch (e: any) {
+            const msg = e?.message ?? '';
+
+            const isSendTxError =
+                e instanceof SendTransactionError || e?.name === 'SendTransactionError';
+
+            if (isSendTxError && msg.includes('already been processed')) {
+                // Preflight is telling us this exact txid already landed.
+                // Derive the signature from the signed tx and continue to confirmation.
+                console.warn(
+                    'sendRawTransaction preflight says "already been processed"; ' +
+                    'treating as success and deriving signature from signed tx.',
+                );
 
-        const conf = await this.connection.confirmTransaction(
-            {
-                signature,
-                blockhash: ctx.blockhash,
-                lastValidBlockHeight: ctx.lastValidBlockHeight,
-            },
-            commitment,
-        );
+                // Assuming SolanaTransaction is a legacy Transaction here.
+                const legacy = signed as unknown as Transaction;
+                const first = legacy.signatures?.[0]?.signature;
 
-        if (conf.value.err) {
-            throw new Error(
-                `Transaction failed: ${JSON.stringify(conf.value.err)}`,
-            );
+                if (!first) {
+                    // No way to recover the txid → rethrow
+                    throw e;
+                }
+
+                signature = bs58.encode(first);
+            } else {
+                // Any other send error is a real failure
+                throw e;
+            }
         }
 
-        return signature;
+        // -------------------------------------------------------------
+        // 2) Poll getSignatureStatuses until confirmed/finalized or timeout
+        // -------------------------------------------------------------
+        const start = Date.now();
+        const timeoutMs = 30_000;      // tune this if you want longer for devnet
+        const pollIntervalMs = 500;    // 0.5s between polls
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const { value } = await this.connection.getSignatureStatuses(
+                [signature],
+                { searchTransactionHistory: true },
+            );
+            const status = value[0];
+
+            if (status) {
+                if (status.err) {
+                    // On-chain error (instruction error, etc.)
+                    throw new Error(
+                        `Transaction failed: ${JSON.stringify(status.err)}`,
+                    );
+                }
+
+                const confirmations = status.confirmations;
+                const confirmationStatus = status.confirmationStatus;
+
+                const satisfied =
+                    confirmationStatus === 'confirmed' ||
+                    confirmationStatus === 'finalized' ||
+                    confirmations === null ||                 // rooted
+                    (confirmations ?? 0) > 0;                 // at least 1 confirmation
+
+                if (satisfied) {
+                    // We consider this successfully confirmed
+                    return signature;
+                }
+            }
+
+            // Timeout guard so we don't spin forever on a tx that never lands
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(
+                    `Transaction confirmation timed out for ${signature}`,
+                );
+            }
+
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
     }
 
     /**
@@ -961,7 +1174,7 @@ export class SolanaStakingClient implements IStakingClient {
         const { blockhash, lastValidBlockHeight } =
             await this.connection.getLatestBlockhash('confirmed');
         tx.recentBlockhash = blockhash;
-        tx.feePayer = this.solPubKey;
+        tx.feePayer = this.feePayer;
         return { tx, blockhash, lastValidBlockHeight };
     }
 
@@ -970,17 +1183,27 @@ export class SolanaStakingClient implements IStakingClient {
      * Ensures we have a Wire pubKey and an Anchor wallet pubKey, and that they match.
      */
     ensureUser() {
-        if (!this.pubKey || !this.anchor.wallet.publicKey) {
-            throw new Error('User Authorization required: pubKey is undefined');
-        }
-        if (
-            this.solPubKey.toBase58() !==
-            this.anchor.wallet.publicKey.toBase58()
-        ) {
-            throw new Error(
-                'Write access requires connected wallet to match pubKey',
-            );
+        if (!this.pubKey) throw new Error('User pubKey is undefined');
+
+        const wallet = this.anchor?.wallet as any;
+        const pk = wallet?.publicKey as SolPubKey | undefined;
+
+        if (!pk) throw new Error('Wallet not connected');
+        if (typeof wallet.signTransaction !== 'function') {
+            throw new Error('Wallet does not support signTransaction');
         }
+
+        // if (!this.pubKey || !this.anchor.wallet.publicKey) {
+        //     throw new Error('User Authorization required: pubKey is undefined');
+        // }
+        // if (
+        //     this.solPubKey.toBase58() !==
+        //     this.anchor.wallet.publicKey.toBase58()
+        // ) {
+        //     throw new Error(
+        //         'Write access requires connected wallet to match pubKey',
+        //     );
+        // }
     }
 
 }

package/src/networks/solana/types.ts

@@ -262,7 +262,7 @@ export type GlobalState = {
     roleWarmupDuration: BN;
 
     /** Wire lifecycle state (preLaunch / postLaunch / refund) */
-    wireState: WireState;
+    wireState: WireState | any;
 
     /** PDA bump */
     bump: number;
@@ -615,7 +615,7 @@ export type LeaderboardState = {
      * Per-validator scores (i64 on-chain).
      * Index corresponds to `registryIndex` in ValidatorRecord.
      */
-    scores: BN[];
+    scores: number[];
 
     /**
      * Sorted indices into `scores[]` / `voteAccounts[]`,
@@ -628,7 +628,7 @@ export type LeaderboardState = {
      * `voteAccounts[i]` is the vote account for validator with
      * `registryIndex == i`.
      */
-    voteAccounts: PublicKey[];
+    voteAccounts: { bytes: number[]; }[];
 
     /**
      * Number of active validators currently tracked in the leaderboard.
@@ -643,7 +643,7 @@ export type LeaderboardState = {
      * Reserved padding / future-proofing on-chain (u64[8]).
      * Not used by client logic, but surfaced for completeness.
      */
-    padding: BN[];
+    padding: number[];
 };
 
 /**