@jpool/bond-sdk 0.9.0-next.9 → 0.10.0

package/dist/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var anchor = require('@coral-xyz/anchor');
+var bytes = require('@coral-xyz/anchor/dist/cjs/utils/bytes');
 var splStakePool = require('@solana/spl-stake-pool');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
@@ -4579,7 +4580,7 @@ var Seeds = /* @__PURE__ */ ((Seeds2) => {
   Seeds2["GlobalState"] = "global_state";
   Seeds2["BondState"] = "bond_state";
   Seeds2["ValidatorBond"] = "validator_bond";
-  Seeds2["PerformanceBond"] = "performance";
+  Seeds2["StandardBond"] = "standard";
   Seeds2["CrowdFundingBond"] = "crowdfunding";
   return Seeds2;
 })(Seeds || {});
@@ -4593,13 +4594,17 @@ init_cjs_shims();
 // src/types/index.ts
 init_cjs_shims();
 var bondTypeToSeed = {
-  performance: "performance" /* PerformanceBond */,
+  standard: "standard" /* StandardBond */,
   crowdfunding: "crowdfunding" /* CrowdFundingBond */
 };
 var BondTypeVariant = {
-  Performance: { performance: {} },
+  Standard: { standard: {} },
   Crowdfunding: { crowdfunding: {} }
 };
+var BondStateStatusVariant = {
+  Active: { active: {} },
+  Disabled: { disabled: {} }
+};
 var BondTransactionType = /* @__PURE__ */ ((BondTransactionType2) => {
   BondTransactionType2["Deposit"] = "deposit";
   BondTransactionType2["Withdrawal"] = "withdrawal";
@@ -4747,23 +4752,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) / web3_js.LAMPORTS_PER_SOL;
-          afterBalance = Number(tx.meta.postBalances[accIdx] ?? 0) / web3_js.LAMPORTS_PER_SOL;
-        }
         history.push({
           signature: sig,
           slot,
           epoch: slotToEpoch(slot, cluster),
           type,
-          amount,
-          beforeBalance,
-          afterBalance
+          amount
         });
       }
     }
@@ -4838,7 +4832,7 @@ var HistoryManager = class {
 
 // src/idl/jbond.json
 var jbond_default = {
-  address: "DBuUGWbLz8CkAMQiagMfrQzj8SSg1rHQJWrTSc97HWfR",
+  address: "BondQ7KqZreTcW2UbeTNDcLCJQ3aXAtLn2Fm6ftaJDU",
   metadata: {
     name: "jbond",
     version: "0.2.1",
@@ -5015,10 +5009,6 @@ var jbond_default = {
         210
       ],
       accounts: [
-        {
-          name: "global_state",
-          writable: true
-        },
         {
           name: "bond_state",
           writable: true,
@@ -5551,9 +5541,6 @@ var jbond_default = {
     },
     {
       name: "global_initialize",
-      docs: [
-        "----------------------------- Global Instructions ----------------------------"
-      ],
       discriminator: [
         30,
         79,
@@ -5602,6 +5589,111 @@ var jbond_default = {
       ],
       args: []
     },
+    {
+      name: "migrate_bond",
+      docs: [
+        "Migrates validator bond data from legacy structure to new structure."
+      ],
+      discriminator: [
+        107,
+        119,
+        59,
+        110,
+        76,
+        18,
+        37,
+        163
+      ],
+      accounts: [
+        {
+          name: "bond_state",
+          writable: true
+        },
+        {
+          name: "legacy_validator_bond",
+          writable: true
+        },
+        {
+          name: "legacy_vote_account"
+        },
+        {
+          name: "validator_bond",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  108,
+                  105,
+                  100,
+                  97,
+                  116,
+                  111,
+                  114,
+                  95,
+                  98,
+                  111,
+                  110,
+                  100
+                ]
+              },
+              {
+                kind: "account",
+                path: "bond_state"
+              },
+              {
+                kind: "account",
+                path: "legacy_vote_account"
+              }
+            ]
+          }
+        },
+        {
+          name: "creator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "session_finish",
+      docs: [
+        "Finishes a bond, preventing further deposits and withdrawals."
+      ],
+      discriminator: [
+        230,
+        209,
+        54,
+        205,
+        127,
+        141,
+        137,
+        113
+      ],
+      accounts: [
+        {
+          name: "bond_state",
+          writable: true
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "bond_state"
+          ]
+        }
+      ],
+      args: []
+    },
     {
       name: "session_start",
       docs: [
@@ -5870,6 +5962,16 @@ var jbond_default = {
       code: 6021,
       name: "InvalidArgument",
       msg: "Invalid argument provided"
+    },
+    {
+      code: 6022,
+      name: "BondNotDisabled",
+      msg: "Bond is not disabled"
+    },
+    {
+      code: 6023,
+      name: "BondNotEnabled",
+      msg: "Bond is not enabled"
     }
   ],
   types: [
@@ -5878,6 +5980,16 @@ var jbond_default = {
       type: {
         kind: "struct",
         fields: [
+          {
+            name: "status",
+            type: {
+              option: {
+                defined: {
+                  name: "BondStatus"
+                }
+              }
+            }
+          },
           {
             name: "new_reserve",
             type: {
@@ -5980,7 +6092,7 @@ var jbond_default = {
           {
             name: "bond_type",
             docs: [
-              "The type of bond (e.g., Performance, Crowdfunding)"
+              "The type of bond (e.g., Standard, Crowdfunding)"
             ],
             type: {
               defined: {
@@ -6048,6 +6160,17 @@ var jbond_default = {
             ],
             type: "i64"
           },
+          {
+            name: "status",
+            docs: [
+              "Current status of the bond"
+            ],
+            type: {
+              defined: {
+                name: "BondStatus"
+              }
+            }
+          },
           {
             name: "bump",
             docs: [
@@ -6058,6 +6181,20 @@ var jbond_default = {
         ]
       }
     },
+    {
+      name: "BondStatus",
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "Active"
+          },
+          {
+            name: "Disabled"
+          }
+        ]
+      }
+    },
     {
       name: "BondType",
       docs: [
@@ -6067,7 +6204,7 @@ var jbond_default = {
         kind: "enum",
         variants: [
           {
-            name: "Performance"
+            name: "Standard"
           },
           {
             name: "Crowdfunding"
@@ -6193,15 +6330,6 @@ var jbond_default = {
       type: {
         kind: "struct",
         fields: [
-          {
-            name: "bonds",
-            docs: [
-              "List of all registered bonds"
-            ],
-            type: {
-              vec: "pubkey"
-            }
-          },
           {
             name: "authority",
             docs: [
@@ -6225,7 +6353,7 @@ var jbond_default = {
         kind: "struct",
         fields: [
           {
-            name: "bond",
+            name: "state",
             type: "pubkey"
           },
           {
@@ -6246,26 +6374,10 @@ var jbond_default = {
               option: "pubkey"
             }
           },
-          {
-            name: "total_compensation_amount",
-            type: "u64"
-          },
-          {
-            name: "last_compensation_amount",
-            type: "u64"
-          },
-          {
-            name: "last_compensation_epoch",
-            type: "u64"
-          },
           {
             name: "created_at",
             type: "i64"
           },
-          {
-            name: "is_active",
-            type: "bool"
-          },
           {
             name: "bump",
             type: "u8"
@@ -6563,10 +6675,8 @@ var JBondClient = class _JBondClient {
    * Build initialize instruction
    */
   async buildBondInitializeIx(props) {
-    const [globalState] = this.pda.globalState();
     const [bondState] = this.pda.bondState(props.bondType, props.name);
     const accounts = {
-      globalState,
       bondState,
       authority: props.authority ?? this.program.provider.wallet?.publicKey,
       reserve: props.reserve,
@@ -6581,8 +6691,6 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.reserveTokenAccount = splToken.getAssociatedTokenAddressSync(mint, props.reserve);
         accounts.mint = mint;
-      },
-      stakeAccount: () => {
       }
     });
     return this.program.methods.bondInitialize({
@@ -6597,6 +6705,7 @@ var JBondClient = class _JBondClient {
   async buildConfigureIx(props) {
     const [bondState] = this.pda.bondState(props.bondType, props.name);
     return this.program.methods.bondConfigure({
+      status: props.bondStateStatus ?? null,
       newReserve: props.newReserve ?? null,
       newAuthority: props.newAuthority ?? null
     }).accountsStrict({
@@ -6612,7 +6721,7 @@ var JBondClient = class _JBondClient {
     if (!creator) {
       throw new Error("Missing creator");
     }
-    const collateralType = (await this.getBondState(bondType, name)).collateralType;
+    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
@@ -6631,9 +6740,6 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.bondTokenAccount = splToken.getAssociatedTokenAddressSync(mint, validatorBond, true);
         Object.assign(accounts, { mint, bondTokenAccount: accounts.bondTokenAccount });
-      },
-      stakeAccount: () => {
-        throw new Error("Stake account collateral type is not currently supported");
       }
     });
     return this.program.methods.bondRegister(bondType, name).accountsPartial(accounts).instruction();
@@ -6647,16 +6753,18 @@ var JBondClient = class _JBondClient {
     const instructions = [];
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
+    console.log("Top up collateral for bond:", { bondState: bondState.toBase58(), validatorBond: validatorBond.toBase58() });
     const bond = await this.getValidatorBond(props.bondType, props.name, props.voteAccount);
     if (!bond) {
       instructions.push(await this.buildRegisterIx({
         bondType: props.bondType,
         name: props.name,
         voteAccount: props.voteAccount,
-        identity: props.identity
+        identity: props.identity,
+        creator: props.payer
       }));
     }
-    const collateralType = (await this.getBondState(bondType, name)).collateralType;
+    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
@@ -6677,13 +6785,6 @@ var JBondClient = class _JBondClient {
         accounts.bondTokenAccount = splToken.getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.tokenProgram = splToken.TOKEN_PROGRAM_ID;
         accounts.associatedTokenProgram = splToken.ASSOCIATED_TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!collateral.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = collateral.stakeAccount;
-        accounts.stakeProgram = web3_js.StakeProgram.programId;
       }
     });
     instructions.push(
@@ -6700,7 +6801,7 @@ var JBondClient = class _JBondClient {
     if (!payer || !destination) {
       throw new Error("Missing payer/destination");
     }
-    const collateralType = (await this.getBondState(bondType, name)).collateralType;
+    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
@@ -6720,27 +6821,20 @@ var JBondClient = class _JBondClient {
         accounts.destinationTokenAccount = splToken.getAssociatedTokenAddressSync(mint, destination, true);
         accounts.bondTokenAccount = splToken.getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.tokenProgram = splToken.TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!withdraw.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = withdraw.stakeAccount;
-        accounts.stakeProgram = web3_js.StakeProgram.programId;
       }
     });
     return this.program.methods.bondWithdraw(this.lamports(withdraw.amount)).accountsPartial(accounts).instruction();
   }
   async buildClaimIx(props) {
-    const { claim, bondType, name } = props;
+    const { bondType, name } = props;
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, props.voteAccount);
-    const reserve = props.reserve ?? (await this.getBondState(bondType, name)).reserve;
+    const reserve = props.reserve ?? (await this.getBondState(bondType, name)).bondState.reserve;
     const authority = props.authority ?? this.program.provider.wallet?.publicKey;
     if (!reserve) {
       throw new Error("Reserve not set");
     }
-    const collateralType = (await this.getBondState(bondType, name)).collateralType;
+    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
@@ -6761,13 +6855,6 @@ var JBondClient = class _JBondClient {
         accounts.bondTokenAccount = splToken.getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.reserveTokenAccount = splToken.getAssociatedTokenAddressSync(mint, reserve, true);
         accounts.tokenProgram = splToken.TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!claim.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = claim.stakeAccount;
-        accounts.stakeProgram = web3_js.StakeProgram.programId;
       }
     });
     return this.program.methods.bondClaim(this.lamports(props.claim.amount)).accountsPartial(
@@ -6782,8 +6869,34 @@ var JBondClient = class _JBondClient {
       newWithdrawAuthority: props.newWithdrawAuthority ?? null
     }).instruction();
   }
-  async buildBondFinishIx(_props) {
-    throw new Error("Crowdfunding bond currently does not support finish operation");
+  async buildBondFinishIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    return this.program.methods.sessionFinish().accountsPartial({
+      bondState,
+      authority: this.program.provider.wallet?.publicKey
+    }).instruction();
+  }
+  async migrateBond(props) {
+    const ix = await this.buildBondMigrateIx(props);
+    return this.provider.sendAndConfirm?.(new web3_js.Transaction().add(ix));
+  }
+  async buildBondMigrateIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    const [legacyValidatorBond] = web3_js.PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("validator_bond"),
+        new web3_js.PublicKey(props.voteAccount).toBuffer()
+      ],
+      this.programId
+    );
+    const [validatorBond] = this.pda.validatorBond(props.bondType, props.name, props.voteAccount);
+    return this.program.methods.migrateBond().accountsPartial({
+      bondState,
+      legacyValidatorBond,
+      legacyVoteAccount: new web3_js.PublicKey(props.voteAccount),
+      validatorBond,
+      creator: this.program.provider.wallet?.publicKey
+    }).instruction();
   }
   async buildBondStartIx(props) {
     const [bondState] = this.pda.bondState(props.bondType, props.name);
@@ -6799,38 +6912,47 @@ var JBondClient = class _JBondClient {
     const [globalState] = this.pda.globalState();
     return await this.program.account.globalState.fetch(globalState);
   }
-  async getBondState(bondType, bondName) {
-    const [bondState] = this.pda.bondState(bondType, bondName);
-    return await this.program.account.bondState.fetch(bondState);
+  /**
+   * Fetch bond state with stats
+   * @param bondType - Type of the bond
+   * @param bondName - Name of the bond
+   * @param withStats
+   */
+  async getBondState(bondType, bondName, withStats = false) {
+    const bondState = await this.program.account.bondState.fetch(this.pda.bondState(bondType, bondName)[0]);
+    return {
+      bondState,
+      stateStats: withStats ? await this.getBondStateStats(bondState) : null
+    };
   }
   /**
    * Get all bond states with total collected collateral
    */
-  async getAllBondStates(bondType) {
+  async getAllBondStates(bondType, sessionStatus) {
     const bondStates = [];
     const bondStateAccounts = await this.program.account.bondState.all();
-    for (const { account: state } of bondStateAccounts) {
+    for (const { publicKey, account: state } of bondStateAccounts) {
       if (!sameVariant(state.bondType, bondType)) {
         continue;
       }
-      const validatorBonds = await this.getValidatorBondsByState(state.bondType, state.name);
-      const balances = await Promise.all(
-        validatorBonds.map(
-          (vb) => this.getValidatorBondBalance(state.bondType, state.name, vb.voteAccount).then((v) => v ?? 0)
-        )
+      if (sessionStatus !== void 0 && this.getBondStateSessionStatus(state) !== sessionStatus) {
+        continue;
+      }
+      const bondStateStats = await this.getBondStateStats(state);
+      bondStates.push(
+        {
+          publicKey,
+          bondState: state,
+          stateStats: bondStateStats
+        }
       );
-      const bondStateStats = {
-        totalCollected: balances.reduce((sum, v) => sum + v, 0),
-        status: await this.getBondStateSessionStatus(state)
-      };
-      bondStates.push([state, bondStateStats]);
     }
     return bondStates;
   }
   /**
    * Get session status for bond state
    */
-  async getBondStateSessionStatus(bondState) {
+  getBondStateSessionStatus(bondState) {
     const now = Math.floor(Date.now() / 1e3);
     if (bondState.sessionFinishTs.toNumber() > now) {
       return 0 /* Live */;
@@ -6838,7 +6960,9 @@ var JBondClient = class _JBondClient {
       return 1 /* Finished */;
     }
   }
-  /** Get all validator bonds for a given bond state */
+  /**
+   * Get all validator bonds for a given bond state
+   */
   async getValidatorBondsByState(bondType, bondName) {
     const validatorBonds = [];
     const bondStatePda = this.pda.bondState(bondType, bondName)[0];
@@ -6857,9 +6981,6 @@ var JBondClient = class _JBondClient {
   }
   /**
    * Fetch validator bond data or null if not found
-   * @param bondType
-   * @param bondName
-   * @param vote
    */
   async getValidatorBond(bondType, bondName, vote) {
     const [address] = this.pda.validatorBond(bondType, bondName, new web3_js.PublicKey(vote));
@@ -6874,7 +6995,7 @@ var JBondClient = class _JBondClient {
    */
   async getBondCollateralType(bondType, bondName) {
     const bondState = await this.getBondState(bondType, bondName);
-    return bondState.collateralType;
+    return bondState.bondState.collateralType;
   }
   /**
    * Get validator bond account balance (in SOL)
@@ -6886,7 +7007,7 @@ var JBondClient = class _JBondClient {
   async getValidatorBondBalance(bondType, bondName, vote) {
     const [address] = this.pda.validatorBond(bondType, bondName, new web3_js.PublicKey(vote));
     const bondStateData = await this.getBondState(bondType, bondName);
-    const bondStateCollateralType = bondStateData.collateralType;
+    const bondStateCollateralType = bondStateData.bondState.collateralType;
     return await matchVariant(bondStateCollateralType, {
       native: async () => {
         const accountInfo = await this.connection.getAccountInfo(address).catch(() => null);
@@ -6901,22 +7022,267 @@ var JBondClient = class _JBondClient {
         const tokenAccount = splToken.getAssociatedTokenAddressSync(mint, address, true);
         try {
           const balance = await this.connection.getTokenAccountBalance(tokenAccount);
-          return Number(balance.value.uiAmount ?? 0);
+          return Number(balance.value.uiAmount ?? 0) * web3_js.LAMPORTS_PER_SOL;
         } catch {
           return 0;
         }
+      }
+    });
+  }
+  /**
+   * Get total collected collateral for a bond state
+   */
+  async getBondStateTotalCollected(bondType, bondName, votes) {
+    const bondStateData = await this.getBondState(bondType, bondName);
+    const bondStateCollateralType = bondStateData.bondState.collateralType;
+    const chunk = (arr, n = 100) => {
+      const res = [];
+      for (let i = 0; i < arr.length; i += n) {
+        res.push(arr.slice(i, i + n));
+      }
+      return res;
+    };
+    return await matchVariant(bondStateCollateralType, {
+      native: async () => {
+        const addresses = votes.map((vote) => {
+          const [address] = this.pda.validatorBond(bondType, bondName, new web3_js.PublicKey(vote));
+          return address;
+        });
+        const accountInfos = await this.connection.getMultipleAccountsInfo(addresses);
+        const balances = await Promise.all(
+          accountInfos.map(async (accountInfo) => {
+            if (!accountInfo) {
+              return 0;
+            }
+            const { lamports } = accountInfo;
+            return lamports;
+          })
+        );
+        return balances.reduce((sum, v) => sum + v, 0);
       },
-      stakeAccount: async () => {
-        const accountInfo = await this.connection.getAccountInfo(address).catch(() => null);
-        if (!accountInfo) {
+      token: async (mint) => {
+        const tokenAccounts = votes.map((vote) => {
+          const [validatorBondAddress] = this.pda.validatorBond(bondType, bondName, new web3_js.PublicKey(vote));
+          return splToken.getAssociatedTokenAddressSync(mint, validatorBondAddress, true);
+        });
+        if (tokenAccounts.length === 0) {
           return 0;
         }
-        const { data, lamports } = accountInfo;
-        const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
-        return Math.max(0, lamports - rentExempt);
+        let total = 0n;
+        for (const part of chunk(tokenAccounts, 100)) {
+          const infos = await this.connection.getMultipleAccountsInfo(part).catch(() => []);
+          for (let i = 0; i < infos.length; i++) {
+            const info = infos[i];
+            if (!info) {
+              continue;
+            }
+            if (info.data.length !== splToken.ACCOUNT_SIZE) {
+              continue;
+            }
+            try {
+              const acc = splToken.AccountLayout.decode(info.data);
+              const raw = BigInt(acc.amount.toString());
+              total += raw;
+            } catch {
+            }
+          }
+        }
+        const asNumber = Number(total);
+        return Number.isFinite(asNumber) ? asNumber : Number.MAX_SAFE_INTEGER;
       }
     });
   }
+  /**
+   * Get transaction history for a specific validator bond account
+   */
+  async getHistory(bondType, bondName, vote, options) {
+    const [legacyValidatorBondAccount] = web3_js.PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("validator_bond" /* ValidatorBond */),
+        new web3_js.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 = bytes.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() / web3_js.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() / web3_js.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
+   * @private
+   */
+  async getBondStateStats(state) {
+    const validatorBonds = await this.getValidatorBondsByState(state.bondType, state.name);
+    const totalCollected = await this.getBondStateTotalCollected(
+      state.bondType,
+      state.name,
+      validatorBonds.map((vb) => vb.voteAccount)
+    );
+    return {
+      totalCollected,
+      status: this.getBondStateSessionStatus(state)
+    };
+  }
   /**
    * Load stake pool account and cache it if not already cached
    * @private
@@ -6963,6 +7329,7 @@ buffer/index.js:
 */
 
 exports.BondClientEnv = BondClientEnv;
+exports.BondStateStatusVariant = BondStateStatusVariant;
 exports.BondTransactionType = BondTransactionType;
 exports.BondTypeVariant = BondTypeVariant;
 exports.ENV_PROGRAM_ID = ENV_PROGRAM_ID;