@wireio/stake 1.0.1 → 2.0.0

package/src/networks/solana/clients/deposit.client.ts

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { AnchorProvider, BN, Program, Wallet } from '@coral-xyz/anchor';
 import {
     SystemProgram,
     Transaction,
@@ -8,52 +8,41 @@ import {
     SYSVAR_CLOCK_PUBKEY,
     SYSVAR_RENT_PUBKEY,
     SYSVAR_STAKE_HISTORY_PUBKEY,
+    Connection,
+    PublicKey,
+    TransactionMessage,
+    LAMPORTS_PER_SOL,
+    Signer,
 } from '@solana/web3.js';
+
 import {
     TOKEN_2022_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
     getAssociatedTokenAddressSync,
 } from '@solana/spl-token';
+import * as multisig from "@sqds/multisig";
 
 import { SolanaProgramService } from '../program';
-import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
+import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 
-import {
-    PROGRAM_IDS,
-    deriveDepositAuthorityPda,
-    deriveLiqsolMintPda,
-    deriveLiqsolMintAuthorityPda,
-    deriveReservePoolPda,
-    deriveVaultPda,
-    deriveStakeControllerStatePda,
-    derivePayoutStatePda,
-    deriveBucketAuthorityPda,
-    derivePayRateHistoryPda,
-    deriveDistributionStatePda,
-    deriveUserRecordPda,
-    deriveEphemeralStakeAddress,
-    deriveWithdrawGlobalPda,
-    deriveStakeAllocationStatePda,
-    deriveStakeMetricsPda,
-    deriveMaintenanceLedgerPda,
-    deriveWithdrawMintAuthorityPda,
-    deriveWithdrawMintMetadataPda,
-    deriveWithdrawNftMintPda,
-    deriveLiqReceiptDataPda,
-    deriveGlobalConfigPda,
-} from '../constants';
 import { GlobalAccount, WalletLike } from '../types';
 
 export class DepositClient {
     private program: Program<LiqsolCore>;
 
+    get connection() {
+        return this.provider.connection;
+    }
+
     get wallet(): WalletLike {
         return this.provider.wallet;
     }
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     /**
@@ -63,7 +52,7 @@ export class DepositClient {
     async buildDepositTx(
         amount: bigint,
         user = this.wallet.publicKey,
-    ): Promise<Transaction> {
+    ): Promise<TransactionInstruction> {
         if (!user) {
             throw new Error(
                 'DepositClient.buildDepositTx: wallet not connected',
@@ -78,16 +67,16 @@ export class DepositClient {
         // -------------------------------------------------------------
         // PDAs
         // -------------------------------------------------------------
-        const depositAuthority = deriveDepositAuthorityPda();
-        const liqsolMint = deriveLiqsolMintPda();
-        const liqsolMintAuthority = deriveLiqsolMintAuthorityPda();
-        const reservePool = deriveReservePoolPda();
-        const vault = deriveVaultPda();
-        const controllerState = deriveStakeControllerStatePda();
-        const payoutState = derivePayoutStatePda();
-        const bucketAuthority = deriveBucketAuthorityPda();
-        const payRateHistory = derivePayRateHistoryPda();
-        const globalConfig = deriveGlobalConfigPda();
+        const depositAuthority = this.pgs.deriveDepositAuthorityPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const vault = this.pgs.deriveVaultPda();
+        const controllerState = this.pgs.deriveStakeControllerStatePda();
+        const payoutState = this.pgs.derivePayoutStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+        const payRateHistory = this.pgs.derivePayRateHistoryPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();
 
         // -------------------------------------------------------------
         // Token-2022 ATAs
@@ -95,15 +84,15 @@ export class DepositClient {
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // -------------------------------------------------------------
         // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
         // -------------------------------------------------------------
-        const distributionState = deriveDistributionStatePda();
-        const userRecord = deriveUserRecordPda(userAta);
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
 
         const bucketTokenAccount = getAssociatedTokenAddressSync(
             liqsolMint,
@@ -116,12 +105,12 @@ export class DepositClient {
         // Ephemeral stake
         // -------------------------------------------------------------
         const seed = Math.floor(Math.random() * 2 ** 32);
-        const ephemeralStake = await deriveEphemeralStakeAddress(user, seed);
+        const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
 
         // -------------------------------------------------------------
         // BUILD IX (MUST MATCH IDL)
         // -------------------------------------------------------------
-        const ix: TransactionInstruction = await this.program.methods
+        return await this.program.methods
             .deposit(new BN(amount.toString()), seed)
             .accounts({
                 user,
@@ -129,7 +118,7 @@ export class DepositClient {
                 systemProgram: SystemProgram.programId,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                liqsolProgram: PROGRAM_IDS.LIQSOL_TOKEN,
+                liqsolProgram: this.pgs.PROGRAM_IDS.LIQSOL_TOKEN,
                 stakeProgram: StakeProgram.programId,
                 liqsolMint,
                 userAta,
@@ -151,10 +140,130 @@ export class DepositClient {
                 globalConfig
             })
             .instruction();
+    }
 
-        return new Transaction().add(ix);
+
+
+    async buildSquadsDepositProposalTx(params: {
+        connection: Connection;
+        multisigPda: PublicKey;
+        amountLamports: bigint;
+        wallet: WalletLikeSigner;   // your WalletLikeSigner type
+        vaultIndex?: number;
+    }): Promise<{
+        tx: Transaction;
+        transactionIndex: bigint;
+        vaultPda: PublicKey;
+    }> {
+        const { connection, multisigPda, amountLamports, wallet } = params;
+        const vaultIndex = params.vaultIndex ?? 0;
+
+        if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+        if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+
+        // 1) vault PDA
+        const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+
+        // 2) build deposit ix where `user` = vaultPda (off-curve OK)
+        const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+
+        // 3) compute next transactionIndex (best-effort; see note below)
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+        const current = BigInt((ms as any).transactionIndex?.toString?.() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        // 4) inner message uses vault as payer
+        const { blockhash } = await connection.getLatestBlockhash("confirmed");
+        const message = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [depositBuilt.ix],
+        });
+
+        // 5) squads instructions (no rpc.*)
+        const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+            multisigPda,
+            transactionIndex,
+            creator: wallet.publicKey,
+            vaultIndex,
+            ephemeralSigners: 0,
+            transactionMessage: message,
+        });
+
+        // const createProposalIx = await multisig.instructions.proposalCreate({
+        //     multisigPda,
+        //     transactionIndex,
+        //     creator: wallet.publicKey,
+        // });
+        // console.log('createVaultTxIx', createVaultTxIx);
+
+
+        // 6) return a normal Transaction for your pipeline
+        const tx = new Transaction().add(createVaultTxIx);
+
+        return { tx, transactionIndex, vaultPda };
     }
 
+    async buildSquadsDepositProposalTx2(params: {
+        connection: Connection;
+        multisigPda: PublicKey;
+        amountLamports: bigint;
+        wallet: WalletLikeSigner;   // your WalletLikeSigner type
+        vaultIndex?: number;
+    }): Promise<{
+        tx: Transaction;
+        transactionIndex: bigint;
+        vaultPda: PublicKey;
+    }> {
+        const { connection, multisigPda, amountLamports, wallet } = params;
+        const vaultIndex = params.vaultIndex ?? 0;
+
+        if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+        if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+
+        // 1) vault PDA
+        const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+
+        // 2) build deposit ix where `user` = vaultPda (off-curve OK)
+        const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+
+        // 3) compute next transactionIndex (best-effort; see note below)
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+        const current = BigInt(ms.transactionIndex?.toString?.() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        // 4) inner message uses vault as payer
+        const { blockhash } = await connection.getLatestBlockhash("confirmed");
+        const message = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [depositBuilt.ix],
+        });
+
+        // 5) squads instructions (no rpc.*)
+        // const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+        //     multisigPda,
+        //     transactionIndex,
+        //     creator: wallet.publicKey,
+        //     vaultIndex,
+        //     ephemeralSigners: 0,
+        //     transactionMessage: message,
+        // });
+
+        const createProposalIx = await multisig.instructions.proposalCreate({
+            multisigPda,
+            transactionIndex,
+            creator: wallet.publicKey,
+        });
+
+        // 6) return a normal Transaction for your pipeline
+        const tx = new Transaction().add(createProposalIx);
+
+        return { tx, transactionIndex, vaultPda };
+    }
+
+
+
     /**
      * Build a withdraw-request transaction:
      *   liqSOL -> SOL via liqsol_core::requestWithdraw.
@@ -182,33 +291,33 @@ export class DepositClient {
         // -------------------------------------------------------------
         // Core program + liqSOL mint / user ATA
         // -------------------------------------------------------------
-        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
 
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // Distribution / balance-tracking
         // user_record is keyed by the user’s liqSOL ATA (same convention
         // as deposit/purchase).
-        const userRecord = deriveUserRecordPda(userAta);
-        const distributionState = deriveDistributionStatePda();
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+        const distributionState = this.pgs.deriveDistributionStatePda();
 
         // Reserve + stake controller PDAs
-        const global = deriveWithdrawGlobalPda();          // withdraw operator state
-        const reservePool = deriveReservePoolPda();
-        const stakeAllocationState = deriveStakeAllocationStatePda();
-        const stakeMetrics = deriveStakeMetricsPda();
-        const maintenanceLedger = deriveMaintenanceLedgerPda();
-        const globalConfig = deriveGlobalConfigPda();      // liqSOL config / roles
+        const global = this.pgs.deriveWithdrawGlobalPda();          // withdraw operator state
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const stakeAllocationState = this.pgs.deriveStakeAllocationStatePda();
+        const stakeMetrics = this.pgs.deriveStakeMetricsPda();
+        const maintenanceLedger = this.pgs.deriveMaintenanceLedgerPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();      // liqSOL config / roles
 
         // -------------------------------------------------------------
         // Need nextReceiptId from withdraw global state
         // -------------------------------------------------------------
-        const globalAcct : GlobalAccount = await this.program.account.global.fetch(global);
+        const globalAcct: GlobalAccount = await this.program.account.global.fetch(global);
 
         const rawId = globalAcct.nextReceiptId;
         let receiptId: bigint;
@@ -231,22 +340,22 @@ export class DepositClient {
         // -------------------------------------------------------------
         // NFT receipt PDAs (mint, metadata, data, ATA)
         // -------------------------------------------------------------
-        const mintAuthority = deriveWithdrawMintAuthorityPda();
-        const metadata = deriveWithdrawMintMetadataPda();
+        const mintAuthority = this.pgs.deriveWithdrawMintAuthorityPda();
+        const metadata = this.pgs.deriveWithdrawMintMetadataPda();
 
-        const nftMint = deriveWithdrawNftMintPda(receiptId);
-        const receiptData = deriveLiqReceiptDataPda(nftMint);
+        const nftMint = this.pgs.deriveWithdrawNftMintPda(receiptId);
+        const receiptData = this.pgs.deriveLiqReceiptDataPda(nftMint);
 
         const owner = user;
         const nftAta = getAssociatedTokenAddressSync(
             nftMint,
             owner,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // Bucket token account (same bucket used by deposit/distribution)
-        const bucketAuthority = deriveBucketAuthorityPda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
         const bucketTokenAccount = getAssociatedTokenAddressSync(
             liqsolMint,
             bucketAuthority,
@@ -289,4 +398,124 @@ export class DepositClient {
 
         return new Transaction().add(ix);
     }
-}
+
+
+
+
+
+    /**
+     * Internal helper: build the liqsol_core::deposit instruction for a specific `user`.
+     * This is the exact same account wiring as buildDepositTx(), but returns the IX
+     * plus useful this.pgs.derived addresses/seed for Squads flows.
+     */
+    private async buildDepositIxForUser(
+        amount: bigint,
+        user: PublicKey,
+    ): Promise<{
+        ix: TransactionInstruction;
+        seed: number;
+        userAta: PublicKey;
+        ephemeralStake: PublicKey;
+    }> {
+        if (!user) {
+            throw new Error("buildDepositIxForUser: user is required");
+        }
+        if (!amount || amount <= BigInt(0)) {
+            throw new Error("buildDepositIxForUser: amount must be > 0");
+        }
+
+        // -------------------------------------------------------------
+        // PDAs
+        // -------------------------------------------------------------
+        const depositAuthority = this.pgs.deriveDepositAuthorityPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const vault = this.pgs.deriveVaultPda();
+        const controllerState = this.pgs.deriveStakeControllerStatePda();
+        const payoutState = this.pgs.derivePayoutStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+        const payRateHistory = this.pgs.derivePayRateHistoryPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();
+
+        // -------------------------------------------------------------
+        // Token-2022 ATAs
+        // -------------------------------------------------------------
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        // -------------------------------------------------------------
+        // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
+        // -------------------------------------------------------------
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        // -------------------------------------------------------------
+        // Ephemeral stake
+        // -------------------------------------------------------------
+        const seed = Math.floor(Math.random() * 2 ** 32);
+        const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
+
+        // -------------------------------------------------------------
+        // BUILD IX (MUST MATCH IDL)
+        // -------------------------------------------------------------
+        const ix: TransactionInstruction = await this.program.methods
+            .deposit(new BN(amount.toString()), seed)
+            .accounts({
+                user,
+                depositAuthority,
+                systemProgram: SystemProgram.programId,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                liqsolProgram: this.pgs.PROGRAM_IDS.LIQSOL_TOKEN,
+                stakeProgram: StakeProgram.programId,
+                liqsolMint,
+                userAta,
+                liqsolMintAuthority,
+                reservePool,
+                vault,
+                ephemeralStake,
+                controllerState,
+                payoutState,
+                bucketAuthority,
+                bucketTokenAccount,
+                userRecord,
+                distributionState,
+                payRateHistory,
+                instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+                clock: SYSVAR_CLOCK_PUBKEY,
+                stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
+                rent: SYSVAR_RENT_PUBKEY,
+                globalConfig,
+            })
+            .instruction();
+
+        return { ix, seed, userAta, ephemeralStake };
+    }
+
+}
+
+// A “wallet-adapter-like” shape (AnchorProvider.wallet matches this)
+type WalletLikeSigner = {
+    publicKey: PublicKey;
+    signTransaction: (tx: Transaction) => Promise<Transaction>;
+};
+
+function isKeypairSigner(x: any): x is { publicKey: PublicKey; secretKey: Uint8Array } {
+    return !!x && x.publicKey instanceof PublicKey && x.secretKey instanceof Uint8Array;
+}
+
+function isWalletLikeSigner(x: any): x is WalletLikeSigner {
+    return !!x && x.publicKey instanceof PublicKey && typeof x.signTransaction === "function";
+}

package/src/networks/solana/clients/distribution.client.ts

@@ -2,14 +2,7 @@ import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 
 import { SolanaProgramService } from '../program';
-import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
-import {
-    deriveDistributionStatePda,
-    deriveGlobalConfigPda,
-    deriveLiqsolMintPda,
-    derivePayRateHistoryPda,
-    deriveUserRecordPda,
-} from '../constants';
+import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 import type { DistributionState, DistributionUserRecord, GlobalConfig, PayRateEntry, PayRateHistory } from '../types';
 import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 import { ceilDiv } from '../utils';
@@ -35,9 +28,11 @@ import { ceilDiv } from '../utils';
 export class DistributionClient {
     private program: Program<LiqsolCore>;
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     get connection() {
@@ -50,7 +45,7 @@ export class DistributionClient {
      * IDL account name: "distributionState"
      */
     async getDistributionState(): Promise<DistributionState | null> {
-        const pda = deriveDistributionStatePda();
+        const pda = this.pgs.deriveDistributionStatePda();
         try {
             return await this.program.account.distributionState.fetch(pda);
         } catch {
@@ -65,7 +60,7 @@ export class DistributionClient {
      * IDL account name: "payRateHistory"
      */
     async getPayRateHistory(): Promise<PayRateHistory | null> {
-        const pda = derivePayRateHistoryPda();
+        const pda = this.pgs.derivePayRateHistoryPda();
         try {
             // Anchor types map directly onto our PayRateHistory TS type
             return (await this.program.account.payRateHistory.fetch(
@@ -82,7 +77,7 @@ export class DistributionClient {
      * IDL account name: "globalConfig"
      */
     async getGlobalConfig(): Promise<GlobalConfig | null> {
-        const pda = deriveGlobalConfigPda();
+        const pda = this.pgs.deriveGlobalConfigPda();
         try {
             return (await this.program.account.globalConfig.fetch(
                 pda,
@@ -99,17 +94,17 @@ export class DistributionClient {
     async getUserRecord(
         ownerOrAta: PublicKey,
     ): Promise<DistributionUserRecord | null> {
-        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
 
         // 1) Try treating ownerOrAta as a WALLET: derive its liqSOL ATA, then userRecord.
         try {
             const ata = getAssociatedTokenAddressSync(
                 liqsolMint,
                 ownerOrAta,
-                false,
+                true,
                 TOKEN_2022_PROGRAM_ID,
             );
-            const pdaFromWallet = deriveUserRecordPda(ata);
+            const pdaFromWallet = this.pgs.deriveUserRecordPda(ata);
             const recFromWallet =
                 await this.program.account.userRecord.fetchNullable(pdaFromWallet);
             if (recFromWallet) {
@@ -121,7 +116,7 @@ export class DistributionClient {
 
         // 2) Fallback: treat ownerOrAta as already being the TOKEN ACCOUNT.
         try {
-            const pdaFromAta = deriveUserRecordPda(ownerOrAta);
+            const pdaFromAta = this.pgs.deriveUserRecordPda(ownerOrAta);
             return await this.program.account.userRecord.fetchNullable(pdaFromAta);
         } catch {
             return null;

package/src/networks/solana/clients/leaderboard.client.ts

@@ -2,11 +2,7 @@ import { AnchorProvider, Program } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 
 import { SolanaProgramService } from '../program';
-import type { ValidatorLeaderboard } from '../../../assets/solana/types/validator_leaderboard';
-import {
-    deriveLeaderboardStatePda,
-    deriveValidatorRecordPda,
-} from '../constants';
+import type { ValidatorLeaderboard } from '../../../assets/solana/devnet/types/validator_leaderboard';
 import { LeaderboardState, ValidatorRecord } from '../types';
 
 /**
@@ -17,13 +13,15 @@ import { LeaderboardState, ValidatorRecord } from '../types';
 export class LeaderboardClient {
     private program: Program<ValidatorLeaderboard>;
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('validatorLeaderboard');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('validatorLeaderboard');
     }
 
     async getState(): Promise<LeaderboardState | null> {
-        const pda = deriveLeaderboardStatePda();
+        const pda = this.pgs.deriveLeaderboardStatePda();
         try {
             // Assumes account name "leaderboardState"
             return await this.program.account.leaderboardState.fetch(pda);
@@ -33,7 +31,7 @@ export class LeaderboardClient {
     }
 
     async getValidatorRecord(voteAccount: PublicKey): Promise<ValidatorRecord | null> {
-        const pda = deriveValidatorRecordPda(voteAccount);
+        const pda = this.pgs.deriveValidatorRecordPda(voteAccount);
         try {
             // Assumes account name "validatorRecord"
             return await this.program.account.validatorRecord.fetchNullable(pda);
@@ -57,7 +55,7 @@ export class LeaderboardClient {
     async getTopValidators(limit = 20): Promise<ValidatorRecord[]> {
         // Try to use the leaderboard state first
         try {
-            const leaderboardPda = deriveLeaderboardStatePda();
+            const leaderboardPda = this.pgs.deriveLeaderboardStatePda();
             const leaderboard: LeaderboardState 
                 = await this.program.account.leaderboardState.fetch(leaderboardPda);