@jpool/bond-sdk 0.3.0-next.7 → 0.3.0-next.8

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
-import { PublicKey, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY, Transaction } from '@solana/web3.js';
+import { PublicKey, Transaction, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY } from '@solana/web3.js';
 import bs58 from 'bs58';
 
 // src/client.ts
@@ -944,7 +944,6 @@ var JBondClient = class _JBondClient {
     return new this(
       new AnchorProvider(
         connection,
-        // @ts-expect-error support anonymous
         wallet ?? { publicKey: PublicKey.default },
         AnchorProvider.defaultOptions()
       ),
@@ -992,23 +991,75 @@ var JBondClient = class _JBondClient {
         this.programId
       );
     },
-    validatorBond: (voteAccount) => {
+    validatorBond: (vote) => {
       return PublicKey.findProgramAddressSync(
         [
           Buffer.from("validator_bond"),
-          voteAccount.toBuffer()
+          new PublicKey(vote).toBuffer()
         ],
         this.programId
       );
     }
   };
+  /**
+   * Initialize the program
+   * Default authority is the provider's wallet
+   */
+  async initialize(props) {
+    const ix = await this.buildInitializeInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Register a new validator
+   * Default creator is the provider's wallet
+   */
+  async registerValidator(props) {
+    const ix = await this.buildRegisterValidatorInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Top up collateral
+   * Default payer is the provider's wallet
+   */
+  async topUpCollateral(props) {
+    const ix = await this.buildTopUpCollateralInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Withdraw collateral
+   * Default withdrawal authority is the provider's wallet
+   * Default destination is the provider's wallet
+   * @return Transaction signature
+   */
+  async withdrawCollateral(props) {
+    const ix = await this.buildWithdrawCollateralInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Claim compensation
+   * Default authority is the provider's wallet
+   * @return Transaction signature
+   */
+  async claimCompensation(props) {
+    const ix = await this.buildClaimInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Set a new authority for the program
+   * Default authority is the provider's wallet
+   * @return Transaction signature
+   */
+  async setAuthority(props) {
+    const ix = await this.buildSetAuthorityInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
   /**
    * Build initialize instruction
-   * @param props
    */
   async buildInitializeInstruction(props) {
     const [globalState] = this.pda.globalState();
-    const { authority, reserveAddress: reserve } = props;
+    const { reserve } = props;
+    const authority = props.authority ?? this.provider.wallet.publicKey;
     return this.program.methods.initialize().accountsPartial({
       globalState,
       authority,
@@ -1017,217 +1068,128 @@ var JBondClient = class _JBondClient {
   }
   /**
    * Build register validator instruction
-   * @param props
    */
   async buildRegisterValidatorInstruction(props) {
-    const { creator, identity, voteAccount, initialCollateral, withdrawalAuthority } = props;
-    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
-    if (accountInfo) {
-      throw new Error("Validator bond account already exists");
-    }
+    const { identity, voteAccount, initialCollateral, withdrawalAuthority } = props;
     const [globalState] = this.pda.globalState();
-    const collateralLamports = new BN(initialCollateral * LAMPORTS_PER_SOL);
-    return this.program.methods.register(collateralLamports, withdrawalAuthority ?? null).accountsPartial({
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(initialCollateral * LAMPORTS_PER_SOL);
+    const creator = props.creator ?? this.provider.wallet.publicKey;
+    return this.program.methods.register(lamports, withdrawalAuthority ?? null).accountsPartial({
       creator,
       globalState,
-      validatorBond: validatorBondAccountAddress,
+      validatorBond,
       identity,
       voteAccount
     }).instruction();
   }
   /**
    * Build top up collateral instruction
-   * @param props
    */
-  buildTopUpCollateralInstruction(props) {
-    const { user, voteAccount, amount } = props;
-    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.topUp(amountLamports).accountsPartial({
-      validatorBond: validatorBondAccountAddress,
-      payer: user
+  async buildTopUpCollateralInstruction(props) {
+    const { voteAccount, amount } = props;
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(amount * LAMPORTS_PER_SOL);
+    const payer = props.payer ?? this.provider.wallet.publicKey;
+    return this.program.methods.topUp(lamports).accountsPartial({
+      validatorBond,
+      payer
     }).instruction();
   }
+  /**
+   * Build withdraw collateral instruction
+   */
   async buildWithdrawCollateralInstruction(props) {
-    const { withdrawalAuthority: user, voteAccount, destination, amount } = props;
-    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.withdraw(amountLamports).accountsPartial({
-      validatorBond: validatorBondAccountAddress,
-      withdrawalAuthority: user,
+    const { voteAccount, amount } = props;
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(amount * LAMPORTS_PER_SOL);
+    const withdrawalAuthority = props.withdrawalAuthority ?? this.provider.wallet.publicKey;
+    const destination = props.destination ?? this.provider.wallet.publicKey;
+    return this.program.methods.withdraw(lamports).accountsPartial({
+      validatorBond,
+      withdrawalAuthority,
       epochSchedule: SYSVAR_EPOCH_SCHEDULE_PUBKEY,
       destination
     }).instruction();
   }
   /**
-   * Build withdraw compensation instruction
-   * @param props
+   * Build claim compensation instruction
    */
-  async buildWithdrawCompensationInstruction(props) {
-    const { authority, voteAccount, amount } = props;
+  async buildClaimInstruction(props) {
     const [globalState] = this.pda.globalState();
-    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    const reserveAddress = (await this.getGlobalState())?.reserveAddress;
-    if (!reserveAddress) {
-      throw new Error("Reserve address is not set in the global state. The program might not be initialized yet.");
+    const [validatorBond] = this.pda.validatorBond(props.voteAccount);
+    const lamports = new BN(props.amount * LAMPORTS_PER_SOL);
+    const authority = props.authority ?? this.provider.wallet.publicKey;
+    let reserve = props.reserve;
+    if (!reserve) {
+      const globalStateData = await this.getGlobalState();
+      reserve = globalStateData.reserve;
+      if (!reserve) {
+        throw new Error("Reserve address is not set in the global state. The program might not be initialized yet.");
+      }
     }
-    return this.program.methods.claim(amountLamports).accountsPartial({
+    return this.program.methods.claim(lamports).accountsPartial({
       globalState,
-      validatorBond: validatorBondAccountAddress,
-      reserve: reserveAddress,
+      validatorBond,
+      reserve,
       authority
     }).instruction();
   }
-  /**
-   * Build multiple withdraw compensation instructions
-   * @param authority
-   * @param withdrawals
-   */
-  buildWithdrawCompensationsInstructions(authority, withdrawals) {
-    return Promise.all(
-      withdrawals.map(
-        ({ voteAccount, amount }) => this.buildWithdrawCompensationInstruction({ authority, voteAccount, amount })
-      )
-    );
-  }
-  /**
-   * Get validator bond account state
-   * @param vote
-   */
-  async getValidatorBond(vote) {
-    const [validatorBondAccountAddress] = this.pda.validatorBond(vote);
-    try {
-      const account = await this.program.account.validatorBond.fetch(validatorBondAccountAddress);
-      return {
-        identity: account.identity.toString(),
-        voteAccount: account.voteAccount.toString(),
-        withdrawalAuthority: account.withdrawalAuthority ? account.withdrawalAuthority.toString() : null,
-        totalCompensationAmount: account.totalCompensationAmount.toNumber() / LAMPORTS_PER_SOL,
-        isActive: account.isActive,
-        createdAt: account.createdAt.toNumber() * 1e3,
-        // Convert i64 Unix seconds (BN) to JS milliseconds
-        bump: account.bump
-      };
-    } catch {
-      return null;
-    }
-  }
   /**
    * Build set authority instruction
    */
   async buildSetAuthorityInstruction(props) {
     const [globalState] = this.pda.globalState();
+    const authority = props.authority ?? this.provider.wallet.publicKey;
     return this.program.methods.setAuthority().accountsStrict({
       globalState,
-      authority: props.authority,
+      authority,
       newAuthority: props.newAuthority
     }).instruction();
   }
   /**
-   * Get the collateral balance of a validator bond account
-   * @param vote - The vote account public key
-   * @returns The available collateral balance in SOL (excluding rent-exempt amount)
-   */
-  async getValidatorCollateralBalance(vote) {
-    const [validatorBondAccountAddress] = this.pda.validatorBond(vote);
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
-    if (!accountInfo) {
-      return 0;
-    }
-    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(
-      accountInfo.data.length
-    );
-    const availableBalance = Math.max(0, accountInfo.lamports - rentExempt);
-    return availableBalance / LAMPORTS_PER_SOL;
-  }
-  /**
-   * Get global state
+   * Fetch global state or throw if not found
    */
   async getGlobalState() {
     const [globalState] = this.pda.globalState();
-    const account = await this.program.account.globalState.fetch(globalState);
-    return {
-      authority: account.authority.toString(),
-      totalValidators: account.totalValidators,
-      totalCompensationAmount: account.totalCompensationAmount.toNumber() / LAMPORTS_PER_SOL,
-      reserveAddress: account.reserve.toString()
-    };
+    return await this.program.account.globalState.fetch(globalState);
   }
   /**
-   * Get current epoch
+   * Fetch validator bond data or null if not found
+   * @param vote
    */
-  async getCurrentEpoch() {
-    const epochInfo = await this.connection.getEpochInfo();
-    return epochInfo.epoch;
+  async getValidatorBond(vote) {
+    const [address] = this.pda.validatorBond(new PublicKey(vote));
+    return await this.program.account.validatorBond.fetchNullable(address);
   }
   /**
-   * Helper methods for backward compatibility (can be removed if not needed)
-   * @param props
+   * Get validator bond account balance (in SOL)
+   * @param vote - Vote account public key
+   * @return Balance in SOL
    */
-  async initialize(props) {
-    const { reserveAddress } = props;
-    const authority = props.authority ?? this.provider.wallet.publicKey;
-    const ix = await this.buildInitializeInstruction({ reserveAddress, authority });
-    return await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-  }
-  // Note: this method will be removed or changed in the future (CLI only)
-  async registerValidator(voteAccount, initialCollateral, withdrawalAuthority, identity) {
-    const identityPubkey = identity ?? this.provider.wallet.publicKey;
-    const ix = await this.buildRegisterValidatorInstruction(
-      { creator: identityPubkey, identity: identityPubkey, voteAccount, initialCollateral, withdrawalAuthority }
-    );
-    return await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-  }
-  async topUpCollateral(voteAccount, amount, validator) {
-    const userPubkey = validator ?? this.provider.wallet.publicKey;
-    const ix = await this.buildTopUpCollateralInstruction(
-      { user: userPubkey, voteAccount, amount }
-    );
-    return await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-  }
-  async withdrawCollateral(voteAccount, destination, amount, withdrawalAuthority) {
-    const authorityPubkey = withdrawalAuthority ?? this.provider.wallet.publicKey;
-    const ix = await this.buildWithdrawCollateralInstruction(
-      { withdrawalAuthority: authorityPubkey, voteAccount, destination, amount }
-    );
-    return await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-  }
-  async claimCompensation(voteAccount, amount, authority) {
-    const authorityPubkey = authority ?? this.provider.wallet.publicKey;
-    const ix = await this.buildWithdrawCompensationInstruction(
-      { authority: authorityPubkey, voteAccount, amount }
-    );
-    return await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
+  async getValidatorBondBalance(vote) {
+    const [address] = this.pda.validatorBond(new PublicKey(vote));
+    const accountInfo = await this.connection.getAccountInfo(address);
+    if (!accountInfo) {
+      return 0;
+    }
+    const { data, lamports } = accountInfo;
+    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
+    const availableBalance = Math.max(0, lamports - rentExempt);
+    return availableBalance / LAMPORTS_PER_SOL;
   }
   /**
    * Get transaction history grouped by epochs
-   * @param voteAccount - The vote account to get history for
+   * @param vote - The vote account to get history for
    * @param epochsCount - Number of recent epochs to return (default: 10)
    * @returns Array of epoch history items sorted by epoch (descending)
    */
-  async getHistoryGroupedByEpochs(voteAccount, epochsCount = 10) {
-    const currentEpoch = await this.getCurrentEpoch();
-    const fullHistory = await this.getFullHistory(voteAccount);
+  async getHistoryGroupedByEpochs(vote, epochsCount = 10) {
+    const epochInfo = await this.connection.getEpochInfo();
+    const fullHistory = await this.getFullHistory(new PublicKey(vote));
     const epochMap = /* @__PURE__ */ new Map();
     for (const item of fullHistory) {
-      if (item.epoch < currentEpoch - epochsCount + 1) {
+      if (item.epoch < epochInfo.epoch - epochsCount + 1) {
         continue;
       }
       if (!epochMap.has(item.epoch)) {
@@ -1254,8 +1216,11 @@ var JBondClient = class _JBondClient {
     }
     return [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
   }
-  async getHistory(voteAccount, options) {
-    const [ValidatorBondAccount] = this.pda.validatorBond(voteAccount);
+  /**
+   * Get transaction history for a specific validator bond account
+   */
+  async getHistory(vote, options) {
+    const [ValidatorBondAccount] = this.pda.validatorBond(new PublicKey(vote));
     const signatures = (await this.connection.getSignaturesForAddress(
       ValidatorBondAccount,
       {