@jpool/bond-sdk 0.8.0-next.4 → 0.9.0-next.1

package/dist/index.mjs

@@ -1291,167 +1291,82 @@ var JBondClient = class _JBondClient {
     const availableBalance = Math.max(0, lamports - rentExempt);
     return availableBalance / LAMPORTS_PER_SOL;
   }
-  /**
-   * Get transaction history grouped by epochs
-   * @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(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 < epochInfo.epoch - epochsCount + 1) {
-        continue;
-      }
-      if (!epochMap.has(item.epoch)) {
-        epochMap.set(item.epoch, {
-          epoch: item.epoch,
-          deposits: 0,
-          withdrawals: 0,
-          balanceChange: 0,
-          signatures: []
-        });
-      }
-      const epochData = epochMap.get(item.epoch);
-      if (item.type === "deposit") {
-        epochData.deposits += item.amount;
-      } else if (item.type === "withdrawal") {
-        epochData.withdrawals += item.amount;
-      }
-      if (!epochData.signatures.includes(item.signature)) {
-        epochData.signatures.push(item.signature);
-      }
-    }
-    for (const epochData of epochMap.values()) {
-      epochData.balanceChange = epochData.deposits - epochData.withdrawals;
-    }
-    return [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
-  }
   /**
    * 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,
-      {
-        limit: options?.limit || 1e3,
-        before: options?.before,
-        until: options?.until
-      }
-    )).filter((sig) => !sig.err);
-    const signatureStrings = signatures.map((sig) => sig.signature);
-    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
+    const cluster = options?.cluster || "mainnet-beta";
+    const [validatorBondAccount] = this.pda.validatorBond(vote);
+    const signatures = await this.fetchSignaturesForValidator(validatorBondAccount, {
+      limit: options?.limit,
+      before: options?.before,
+      until: options?.until
+    });
+    if (signatures.length === 0) {
+      return [];
+    }
+    const signatureStrings = signatures.map((s) => s.signature);
+    const parsedTxs = await this.fetchParsedTransactions(signatureStrings);
+    const txBySig = /* @__PURE__ */ new Map();
+    for (let i = 0; i < signatureStrings.length; i++) {
+      const requestedSig = signatureStrings[i];
+      const tx = parsedTxs[i] ?? null;
+      if (tx && tx.transaction && Array.isArray(tx.transaction.signatures) && tx.transaction.signatures[0]) {
+        const txSig = tx.transaction.signatures[0];
+        if (txSig !== requestedSig) {
+          const found = parsedTxs.find((t) => t && t.transaction && t.transaction.signatures && t.transaction.signatures[0] === requestedSig) ?? null;
+          txBySig.set(requestedSig, found);
+          continue;
         }
-      );
-      allTransactions.push(...transactions);
+      }
+      txBySig.set(requestedSig, tx);
     }
-    const cluster = options?.cluster || "mainnet-beta";
     const history = [];
-    for (const [idx, tx] of allTransactions.entries()) {
-      const sigInfo = signatures[idx];
+    for (const sigInfo of signatures) {
+      const sig = sigInfo.signature;
+      const tx = txBySig.get(sig) ?? null;
       if (!tx || !tx.meta || tx.meta.err !== null) {
         continue;
       }
       try {
-        const slot = tx.slot || 0;
+        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 >= 16) {
-                const discriminator = dataBuffer.slice(0, 8);
-                const bondInitDiscriminator = this.getInstructionDiscriminator("register");
-                const bondTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
-                const withdrawCompensationDiscriminator = this.getInstructionDiscriminator("claim");
-                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
-                const amountBytes = dataBuffer.slice(8, 16);
-                const amountBN = new BN(amountBytes, "le");
-                amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
-                if (Buffer.from(discriminator).equals(Buffer.from(bondInitDiscriminator))) {
-                  type = "deposit" /* Deposit */;
-                } else if (Buffer.from(discriminator).equals(Buffer.from(bondTopUpDiscriminator))) {
-                  type = "deposit" /* Deposit */;
-                } else if (Buffer.from(discriminator).equals(Buffer.from(withdrawCompensationDiscriminator))) {
-                  type = "compensation" /* Compensation */;
-                } else if (Buffer.from(discriminator).equals(Buffer.from(bondWithdrawDiscriminator))) {
-                  type = "withdrawal" /* Withdrawal */;
-                }
-              }
-            } catch {
-              console.warn("Failed to decode instruction data");
-            }
-            if (type && amount > 0) {
-              let beforeBalance;
-              let afterBalance;
-              const accountIndex = tx.transaction.message.accountKeys.findIndex(
-                (key) => key.pubkey.equals(ValidatorBondAccount)
-              );
-              if (accountIndex !== -1 && tx.meta.preBalances && tx.meta.postBalances) {
-                beforeBalance = Number(tx.meta.preBalances[accountIndex] || 0) / LAMPORTS_PER_SOL;
-                afterBalance = Number(tx.meta.postBalances[accountIndex] || 0) / LAMPORTS_PER_SOL;
-              }
-              history.push({
-                signature: sigInfo.signature,
-                slot,
-                epoch: slotToEpoch(slot, cluster),
-                type,
-                amount,
-                beforeBalance,
-                afterBalance
-              });
-            }
+          if (!("programId" in instruction)) {
+            continue;
+          }
+          if (!instruction.programId.equals(this.options.programId ?? this.program.programId)) {
+            continue;
           }
+          if (instruction.parsed) {
+            continue;
+          }
+          const { type, amount } = this.decodeInstructionData(instruction.data);
+          if (!type || amount <= 0) {
+            continue;
+          }
+          let beforeBalance;
+          let afterBalance;
+          const accountIndex = tx.transaction.message.accountKeys.findIndex((k) => k.pubkey.equals(validatorBondAccount));
+          if (accountIndex !== -1 && tx.meta.preBalances && tx.meta.postBalances) {
+            beforeBalance = Number(tx.meta.preBalances[accountIndex] || 0) / LAMPORTS_PER_SOL;
+            afterBalance = Number(tx.meta.postBalances[accountIndex] || 0) / LAMPORTS_PER_SOL;
+          }
+          history.push({
+            signature: sigInfo.signature,
+            slot,
+            epoch: slotToEpoch(slot, cluster),
+            type,
+            amount,
+            beforeBalance,
+            afterBalance
+          });
         }
       } 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 voteAccount
-   * @param pageSize
-   */
-  async getFullHistory(voteAccount, pageSize = 100) {
-    const allHistory = [];
-    let before;
-    while (true) {
-      const batch = await this.getHistory(voteAccount, {
-        limit: pageSize,
-        before
-      });
-      if (batch.length === 0) {
-        break;
-      }
-      allHistory.push(...batch);
-      before = batch.at(-1)?.signature;
-      if (batch.length < pageSize) {
-        break;
-      }
-    }
-    return allHistory;
+    return history.sort((a, b) => b.slot - a.slot);
   }
   /**
    * Get instruction discriminator from IDL
@@ -1468,6 +1383,65 @@ var JBondClient = class _JBondClient {
     }
     return new Uint8Array(instruction.discriminator);
   }
+  async fetchSignaturesForValidator(validatorBondAccount, options) {
+    const sigs = await this.connection.getSignaturesForAddress(
+      validatorBondAccount,
+      {
+        limit: options?.limit || 1e3,
+        before: options?.before,
+        until: options?.until
+      }
+    );
+    return sigs.filter((s) => !s.err);
+  }
+  // Fetch parsed transactions in batches to avoid rate limits
+  async fetchParsedTransactions(signatureStrings, batchSize = 100) {
+    const allTxs = [];
+    for (let i = 0; i < signatureStrings.length; i += batchSize) {
+      const batch = signatureStrings.slice(i, i + batchSize);
+      const txs = await this.connection.getParsedTransactions(batch, {
+        maxSupportedTransactionVersion: 0
+      });
+      allTxs.push(...txs);
+    }
+    return allTxs;
+  }
+  // Decode instruction data to determine transaction type and amount
+  decodeInstructionData(data) {
+    if (!data) {
+      return { type: null, amount: 0 };
+    }
+    try {
+      const dataBuffer = bs58.decode(data);
+      if (dataBuffer.length < 16) {
+        return { type: null, amount: 0 };
+      }
+      const discriminator = dataBuffer.slice(0, 8);
+      const amountBytes = dataBuffer.slice(8, 16);
+      const amountBN = new BN(amountBytes, "le");
+      const amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
+      const bondInitDiscriminator = this.getInstructionDiscriminator("register");
+      const bondTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
+      const withdrawCompensationDiscriminator = this.getInstructionDiscriminator("claim");
+      const bondWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
+      if (Buffer.from(discriminator).equals(Buffer.from(bondInitDiscriminator))) {
+        return { type: "deposit" /* Deposit */, amount };
+      }
+      if (Buffer.from(discriminator).equals(Buffer.from(bondTopUpDiscriminator))) {
+        return { type: "deposit" /* Deposit */, amount };
+      }
+      if (Buffer.from(discriminator).equals(Buffer.from(withdrawCompensationDiscriminator))) {
+        return { type: "compensation" /* Compensation */, amount };
+      }
+      if (Buffer.from(discriminator).equals(Buffer.from(bondWithdrawDiscriminator))) {
+        return { type: "withdrawal" /* Withdrawal */, amount };
+      }
+      return { type: null, amount: 0 };
+    } catch (err) {
+      console.warn("Failed to decode instruction data", err);
+      return { type: null, amount: 0 };
+    }
+  }
 };
 
 export { BondClientEnv, BondTransactionType, ENV_PROGRAM_ID, JBondClient, NodeWallet };