@jpool/bond-sdk 0.9.0-next.24 → 0.9.0-next.26

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
+import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes';
 import { getStakePoolAccount, STAKE_POOL_PROGRAM_ID, StakePoolInstruction } from '@solana/spl-stake-pool';
 import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, ACCOUNT_SIZE, AccountLayout } from '@solana/spl-token';
 import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import bs58 from 'bs58';
+import bs58$1 from 'bs58';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -4716,23 +4717,12 @@ var HistoryManager = class {
         if (!type || amount <= 0) {
           continue;
         }
-        let beforeBalance;
-        let afterBalance;
-        const accIdx = tx.transaction.message.accountKeys.findIndex(
-          (k) => k.pubkey.equals(validatorBondAccount)
-        );
-        if (accIdx !== -1 && tx.meta.preBalances && tx.meta.postBalances) {
-          beforeBalance = Number(tx.meta.preBalances[accIdx] ?? 0) / LAMPORTS_PER_SOL;
-          afterBalance = Number(tx.meta.postBalances[accIdx] ?? 0) / LAMPORTS_PER_SOL;
-        }
         history.push({
           signature: sig,
           slot,
           epoch: slotToEpoch(slot, cluster),
           type,
-          amount,
-          beforeBalance,
-          afterBalance
+          amount
         });
       }
     }
@@ -4775,7 +4765,7 @@ var HistoryManager = class {
       return { type: null, amount: 0 };
     }
     try {
-      const buf = bs58.decode(data);
+      const buf = bs58$1.decode(data);
       if (buf.length < 16) {
         return { type: null, amount: 0 };
       }
@@ -7069,6 +7059,180 @@ var JBondClient = class _JBondClient {
       }
     });
   }
+  /**
+   * Get transaction history for a specific validator bond account
+   */
+  async getHistory(bondType, bondName, vote, options) {
+    const [legacyValidatorBondAccount] = PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("validator_bond" /* ValidatorBond */),
+        new PublicKey(vote).toBuffer()
+      ],
+      this.programId
+    );
+    const validatorBond = this.pda.validatorBond(bondType, bondName, vote);
+    const legacySignatures = (await this.connection.getSignaturesForAddress(
+      legacyValidatorBondAccount,
+      {
+        limit: options?.limit || 1e3,
+        before: options?.before,
+        until: options?.until
+      },
+      "confirmed"
+    )).filter((sig) => !sig.err);
+    const newSignatures = (await this.connection.getSignaturesForAddress(
+      validatorBond[0],
+      {
+        limit: options?.limit || 1e3,
+        before: options?.before,
+        until: options?.until
+      },
+      "confirmed"
+    )).filter((sig) => !sig.err);
+    const signatureStrings = legacySignatures.map((sig) => sig.signature);
+    signatureStrings.push(...newSignatures.map((sig) => sig.signature));
+    const signatures = [...legacySignatures, ...newSignatures];
+    const BATCH_SIZE = 100;
+    const allTransactions = [];
+    for (let i = 0; i < signatureStrings.length; i += BATCH_SIZE) {
+      const batch = signatureStrings.slice(i, i + BATCH_SIZE);
+      const transactions = await this.connection.getParsedTransactions(
+        batch,
+        {
+          maxSupportedTransactionVersion: 0,
+          commitment: "confirmed"
+        }
+      );
+      allTransactions.push(...transactions);
+    }
+    const cluster = options?.cluster || "mainnet-beta";
+    const history = [];
+    for (const [idx, tx] of allTransactions.entries()) {
+      const sigInfo = signatures[idx];
+      if (!tx || !tx.meta || tx.meta.err !== null) {
+        continue;
+      }
+      try {
+        const slot = tx.slot || 0;
+        const instructions = tx.transaction.message.instructions;
+        for (const instruction of instructions) {
+          if ("programId" in instruction && instruction.programId.equals(this.options.programId ?? this.program.programId)) {
+            const ixData = instruction;
+            if ("parsed" in ixData && ixData.parsed) {
+              continue;
+            }
+            const data = ixData.data;
+            if (!data) {
+              continue;
+            }
+            let type = null;
+            let amount = 0;
+            try {
+              const dataBuffer = bs58.decode(data);
+              if (dataBuffer.length >= 8) {
+                const discriminator = dataBuffer.subarray(0, 8);
+                const legacyRegisterDiscriminator = this.getInstructionDiscriminator("register");
+                const legacyTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
+                const legacyClaimDiscriminator = this.getInstructionDiscriminator("claim");
+                const legacyWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
+                const bondRegisterDiscriminator = this.getInstructionDiscriminator("bondRegister");
+                const bondTopUpDiscriminator = this.getInstructionDiscriminator("bondTopUp");
+                const bondClaimDiscriminator = this.getInstructionDiscriminator("bondClaim");
+                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("bondWithdraw");
+                console.log("Discriminator:", Buffer.from(discriminator).toString("hex"));
+                if (Buffer.from(discriminator).equals(Buffer.from(legacyRegisterDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondRegisterDiscriminator))) {
+                  type = "deposit" /* Deposit */;
+                  if (dataBuffer.length >= 16 && Buffer.from(discriminator).equals(Buffer.from(legacyRegisterDiscriminator))) {
+                    const amountBytes = dataBuffer.subarray(8, 16);
+                    const amountBN = new import_bn2.BN(amountBytes, "le");
+                    amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
+                  }
+                } else if (dataBuffer.length >= 16) {
+                  const amountBytes = dataBuffer.subarray(8, 16);
+                  const amountBN = new import_bn2.BN(amountBytes, "le");
+                  amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
+                  if (Buffer.from(discriminator).equals(Buffer.from(legacyTopUpDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondTopUpDiscriminator))) {
+                    type = "deposit" /* Deposit */;
+                  } else if (Buffer.from(discriminator).equals(Buffer.from(legacyClaimDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondClaimDiscriminator))) {
+                    type = "compensation" /* Compensation */;
+                  } else if (Buffer.from(discriminator).equals(Buffer.from(legacyWithdrawDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondWithdrawDiscriminator))) {
+                    type = "withdrawal" /* Withdrawal */;
+                  }
+                }
+              }
+            } catch (e) {
+              console.warn("Failed to decode instruction data:", e);
+            }
+            if (type && (amount > 0 || type === "deposit" /* Deposit */)) {
+              history.push({
+                signature: sigInfo.signature,
+                slot,
+                epoch: slotToEpoch(slot, cluster),
+                type,
+                amount
+              });
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error processing transaction ${sigInfo.signature}:`, error);
+      }
+    }
+    return history.toSorted((a, b) => b.slot - a.slot);
+  }
+  /**
+   * Get full transaction history by paginating through results
+   * @param bondType
+   * @param bondName
+   * @param voteAccount
+   * @param pageSize
+   */
+  async getFullHistory(bondType, bondName, voteAccount, pageSize = 100) {
+    const allHistory = [];
+    let before;
+    while (true) {
+      const batch = await this.getHistory(bondType, bondName, voteAccount, {
+        limit: pageSize,
+        before
+      });
+      if (batch.length === 0) {
+        break;
+      }
+      allHistory.push(...batch);
+      before = batch.at(-1)?.signature;
+      if (batch.length < pageSize) {
+        break;
+      }
+    }
+    return allHistory;
+  }
+  /**
+   * Get instruction discriminator from IDL
+   * @param instructionName
+   * @private
+   */
+  getInstructionDiscriminator(instructionName) {
+    const legacyDiscriminators = {
+      register: [211, 124, 67, 15, 211, 194, 178, 240],
+      topUp: [181, 157, 89, 67, 143, 182, 52, 72],
+      claim: [62, 198, 214, 193, 213, 159, 108, 210],
+      withdraw: [183, 18, 70, 156, 148, 109, 161, 34]
+    };
+    if (legacyDiscriminators[instructionName]) {
+      return new Uint8Array(legacyDiscriminators[instructionName]);
+    }
+    if (instructionName.startsWith("bond")) {
+      const instruction = this.program.idl.instructions.find((ix) => ix.name === instructionName);
+      if (!instruction) {
+        throw new Error(`Instruction ${instructionName} not found in IDL`);
+      }
+      if (!instruction.discriminator || !Array.isArray(instruction.discriminator)) {
+        throw new Error(`Discriminator not found for instruction ${instructionName}`);
+      }
+      return new Uint8Array(instruction.discriminator);
+    }
+    throw new Error(`Unknown instruction: ${instructionName}`);
+  }
   /**
    * Get bond state stats
    * @param state