@jpool/bond-sdk 0.0.1-next.0 → 0.1.0-next.1

package/dist/index.mjs

@@ -1,1193 +0,0 @@
-import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { Connection, PublicKey, SystemProgram, LAMPORTS_PER_SOL, Transaction, Keypair } from '@solana/web3.js';
-import bs58 from 'bs58';
-import { readFileSync } from 'fs';
-import dotenv from 'dotenv';
-
-// src/client.ts
-
-// src/helpers.ts
-var SLOTS_PER_EPOCH_MAINNET = 432e3;
-var SLOTS_PER_EPOCH_DEVNET = 4e5;
-function slotToEpoch(slot, cluster) {
-  const slotsPerEpoch = cluster === "mainnet-beta" ? SLOTS_PER_EPOCH_MAINNET : SLOTS_PER_EPOCH_DEVNET;
-  return Math.floor(slot / slotsPerEpoch);
-}
-
-// src/idl/jbond.json
-var jbond_default = {
-  address: "4a3YovKEfm4jWhczCzJciHXL1xVkXWfGQjRCaMft7M4G",
-  metadata: {
-    name: "jbond",
-    version: "0.1.0",
-    spec: "0.1.0",
-    description: "Validator compensation program for boosting APR"
-  },
-  instructions: [
-    {
-      name: "bond_init",
-      docs: [
-        "Register validator and fund initial collateral"
-      ],
-      discriminator: [
-        220,
-        108,
-        156,
-        81,
-        16,
-        185,
-        144,
-        157
-      ],
-      accounts: [
-        {
-          name: "global_state",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  103,
-                  108,
-                  111,
-                  98,
-                  97,
-                  108,
-                  95,
-                  115,
-                  116,
-                  97,
-                  116,
-                  101
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "validator_bond_account",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  118,
-                  97,
-                  108,
-                  105,
-                  100,
-                  97,
-                  116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
-                ]
-              },
-              {
-                kind: "account",
-                path: "vote_account"
-              }
-            ]
-          }
-        },
-        {
-          name: "identity"
-        },
-        {
-          name: "vote_account"
-        },
-        {
-          name: "creator",
-          docs: [
-            "The account creating the bond (pays for account creation and initial collateral)"
-          ],
-          writable: true,
-          signer: true
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "initial_collateral",
-          type: "u64"
-        },
-        {
-          name: "withdrawal_authority",
-          type: {
-            option: "pubkey"
-          }
-        }
-      ]
-    },
-    {
-      name: "bond_top_up",
-      docs: [
-        "Top up collateral for existing validator"
-      ],
-      discriminator: [
-        132,
-        225,
-        254,
-        187,
-        152,
-        162,
-        176,
-        66
-      ],
-      accounts: [
-        {
-          name: "validator_bond_account",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  118,
-                  97,
-                  108,
-                  105,
-                  100,
-                  97,
-                  116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
-                ]
-              },
-              {
-                kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
-              }
-            ]
-          }
-        },
-        {
-          name: "depositor",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
-    },
-    {
-      name: "bond_withdraw",
-      discriminator: [
-        99,
-        64,
-        127,
-        178,
-        53,
-        117,
-        70,
-        204
-      ],
-      accounts: [
-        {
-          name: "validator_bond_account",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  118,
-                  97,
-                  108,
-                  105,
-                  100,
-                  97,
-                  116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
-                ]
-              },
-              {
-                kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
-              }
-            ]
-          }
-        },
-        {
-          name: "withdrawal_authority",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "destination",
-          writable: true
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
-    },
-    {
-      name: "initialize",
-      docs: [
-        "Initialize the global state and reserve vault"
-      ],
-      discriminator: [
-        175,
-        175,
-        109,
-        31,
-        13,
-        152,
-        155,
-        237
-      ],
-      accounts: [
-        {
-          name: "global_state",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  103,
-                  108,
-                  111,
-                  98,
-                  97,
-                  108,
-                  95,
-                  115,
-                  116,
-                  97,
-                  116,
-                  101
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "authority",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "reserve"
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: []
-    },
-    {
-      name: "withdraw_compensation",
-      docs: [
-        "Withdraw compensation from validator to reserve (oracle only)"
-      ],
-      discriminator: [
-        10,
-        228,
-        22,
-        213,
-        205,
-        117,
-        181,
-        75
-      ],
-      accounts: [
-        {
-          name: "global_state",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  103,
-                  108,
-                  111,
-                  98,
-                  97,
-                  108,
-                  95,
-                  115,
-                  116,
-                  97,
-                  116,
-                  101
-                ]
-              }
-            ]
-          }
-        },
-        {
-          name: "validator_bond_account",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  118,
-                  97,
-                  108,
-                  105,
-                  100,
-                  97,
-                  116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
-                ]
-              },
-              {
-                kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
-              }
-            ]
-          }
-        },
-        {
-          name: "reserve",
-          writable: true
-        },
-        {
-          name: "authority",
-          docs: [
-            "Authority that can trigger claims"
-          ],
-          signer: true
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
-    }
-  ],
-  accounts: [
-    {
-      name: "GlobalState",
-      discriminator: [
-        163,
-        46,
-        74,
-        168,
-        216,
-        123,
-        133,
-        98
-      ]
-    },
-    {
-      name: "ValidatorBondAccount",
-      discriminator: [
-        25,
-        67,
-        241,
-        227,
-        226,
-        104,
-        108,
-        73
-      ]
-    }
-  ],
-  events: [
-    {
-      name: "CollateralToppedUp",
-      discriminator: [
-        189,
-        137,
-        204,
-        58,
-        135,
-        182,
-        19,
-        176
-      ]
-    },
-    {
-      name: "CollateralWithdrawn",
-      discriminator: [
-        51,
-        224,
-        133,
-        106,
-        74,
-        173,
-        72,
-        82
-      ]
-    },
-    {
-      name: "CompensationClaimed",
-      discriminator: [
-        36,
-        159,
-        41,
-        178,
-        104,
-        135,
-        220,
-        32
-      ]
-    },
-    {
-      name: "ValidatorRegistered",
-      discriminator: [
-        20,
-        20,
-        190,
-        191,
-        53,
-        174,
-        95,
-        72
-      ]
-    }
-  ],
-  errors: [
-    {
-      code: 6e3,
-      name: "InvalidVoteAccount",
-      msg: "Invalid vote account"
-    },
-    {
-      code: 6001,
-      name: "IdentityMismatch",
-      msg: "Identity does not match vote account"
-    },
-    {
-      code: 6002,
-      name: "InsufficientCollateral",
-      msg: "Insufficient collateral amount"
-    },
-    {
-      code: 6003,
-      name: "TargetAprTooLow",
-      msg: "Target APR is below minimum threshold"
-    },
-    {
-      code: 6004,
-      name: "MathOverflow",
-      msg: "Math overflow"
-    },
-    {
-      code: 6005,
-      name: "InvalidAmount",
-      msg: "Invalid amount"
-    },
-    {
-      code: 6006,
-      name: "ValidatorNotActive",
-      msg: "Validator boost account is not active"
-    },
-    {
-      code: 6007,
-      name: "ValidatorAlreadyRegistered",
-      msg: "Validator already registered"
-    },
-    {
-      code: 6008,
-      name: "Unauthorized",
-      msg: "Unauthorized"
-    }
-  ],
-  types: [
-    {
-      name: "CollateralToppedUp",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "validator",
-            type: "pubkey"
-          },
-          {
-            name: "amount",
-            type: "u64"
-          },
-          {
-            name: "new_total",
-            type: "u64"
-          },
-          {
-            name: "timestamp",
-            type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "CollateralWithdrawn",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "validator",
-            type: "pubkey"
-          },
-          {
-            name: "amount",
-            type: "u64"
-          },
-          {
-            name: "remaining_collateral",
-            type: "u64"
-          },
-          {
-            name: "timestamp",
-            type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "CompensationClaimed",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "validator",
-            type: "pubkey"
-          },
-          {
-            name: "amount",
-            type: "u64"
-          },
-          {
-            name: "remaining_collateral",
-            type: "u64"
-          },
-          {
-            name: "total_withdrawn",
-            type: "u64"
-          },
-          {
-            name: "epoch",
-            type: "u64"
-          },
-          {
-            name: "timestamp",
-            type: "i64"
-          }
-        ]
-      }
-    },
-    {
-      name: "GlobalState",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "authority",
-            type: "pubkey"
-          },
-          {
-            name: "reserve",
-            type: "pubkey"
-          },
-          {
-            name: "total_validators",
-            type: "u32"
-          },
-          {
-            name: "total_withdrawn",
-            type: "u64"
-          },
-          {
-            name: "bump",
-            type: "u8"
-          }
-        ]
-      }
-    },
-    {
-      name: "ValidatorBondAccount",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "identity",
-            type: "pubkey"
-          },
-          {
-            name: "vote_account",
-            type: "pubkey"
-          },
-          {
-            name: "creator",
-            type: "pubkey"
-          },
-          {
-            name: "withdrawal_authority",
-            type: {
-              option: "pubkey"
-            }
-          },
-          {
-            name: "total_withdrawn",
-            type: "u64"
-          },
-          {
-            name: "last_withdrawal_epoch",
-            type: "u64"
-          },
-          {
-            name: "is_active",
-            type: "bool"
-          },
-          {
-            name: "created_at",
-            type: "i64"
-          },
-          {
-            name: "bump",
-            type: "u8"
-          }
-        ]
-      }
-    },
-    {
-      name: "ValidatorRegistered",
-      type: {
-        kind: "struct",
-        fields: [
-          {
-            name: "validator",
-            type: "pubkey"
-          },
-          {
-            name: "vote_account",
-            type: "pubkey"
-          },
-          {
-            name: "collateral_amount",
-            type: "u64"
-          },
-          {
-            name: "timestamp",
-            type: "i64"
-          }
-        ]
-      }
-    }
-  ]
-};
-
-// src/types/index.ts
-var BondTransactionType = /* @__PURE__ */ ((BondTransactionType2) => {
-  BondTransactionType2["Deposit"] = "deposit";
-  BondTransactionType2["Withdrawal"] = "withdrawal";
-  BondTransactionType2["Compensation"] = "compensation";
-  return BondTransactionType2;
-})(BondTransactionType || {});
-
-// src/utils/wallet.ts
-function isVersionedTransaction(tx) {
-  return "version" in tx;
-}
-var NodeWallet = class {
-  constructor(payer) {
-    this.payer = payer;
-  }
-  async signTransaction(tx) {
-    if (isVersionedTransaction(tx)) {
-      tx.sign([this.payer]);
-    } else {
-      tx.partialSign(this.payer);
-    }
-    return tx;
-  }
-  async signAllTransactions(txs) {
-    return txs.map((t) => {
-      if (isVersionedTransaction(t)) {
-        t.sign([this.payer]);
-      } else {
-        t.partialSign(this.payer);
-      }
-      return t;
-    });
-  }
-  get publicKey() {
-    return this.payer.publicKey;
-  }
-};
-
-// src/client.ts
-var JBondClient = class _JBondClient {
-  connection;
-  program;
-  provider;
-  config;
-  constructor(config, wallet) {
-    this.config = config;
-    this.connection = new Connection(config.rpcUrl, "confirmed");
-    this.provider = new AnchorProvider(
-      this.connection,
-      // @ts-expect-error support anonymous
-      wallet ?? { publicKey: PublicKey.default },
-      AnchorProvider.defaultOptions()
-    );
-    this.program = new Program(jbond_default, this.provider);
-  }
-  /**
-   * Creates an instance of `JBondClient` using a provided connection and wallet.
-   */
-  static fromWallet(config, wallet) {
-    return new this(config, wallet);
-  }
-  /**
-   * Creates an instance of `JBondClient` using the provided connection and keypair.
-   */
-  static fromKeypair(config, keypair) {
-    return _JBondClient.fromWallet(config, new NodeWallet(keypair));
-  }
-  // Get PDA for global state
-  getGlobalStatePDA() {
-    return PublicKey.findProgramAddressSync(
-      [Buffer.from("global_state")],
-      this.program.programId
-    );
-  }
-  // Get PDA for validator bond account
-  getValidatorBondPDA(voteAccount) {
-    return PublicKey.findProgramAddressSync(
-      [
-        Buffer.from("validator_bond"),
-        voteAccount.toBuffer()
-      ],
-      this.program.programId
-    );
-  }
-  // Build initialize instruction
-  async buildInitializeInstruction(props) {
-    const [globalState] = this.getGlobalStatePDA();
-    return this.program.methods.initialize().accountsStrict({
-      globalState,
-      authority: props.authority,
-      reserve: this.config.reserveAddress,
-      systemProgram: SystemProgram.programId
-    }).instruction();
-  }
-  // Build register validator instruction
-  async buildRegisterValidatorInstruction(props) {
-    const { creator, identity, voteAccount, initialCollateral, withdrawalAuthority } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
-    if (accountInfo) {
-      throw new Error("Validator bond account already exists");
-    }
-    const [globalState] = this.getGlobalStatePDA();
-    const collateralLamports = new BN(initialCollateral * LAMPORTS_PER_SOL);
-    return this.program.methods.bondInit(collateralLamports, withdrawalAuthority ?? null).accountsStrict({
-      creator,
-      globalState,
-      validatorBondAccount: validatorBondAccountAddress,
-      identity,
-      voteAccount,
-      systemProgram: SystemProgram.programId
-    }).instruction();
-  }
-  // Build top up collateral instruction
-  buildTopUpCollateralInstruction(props) {
-    const { user, voteAccount, amount } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.bondTopUp(amountLamports).accountsStrict({
-      validatorBondAccount: validatorBondAccountAddress,
-      depositor: user,
-      systemProgram: SystemProgram.programId
-    }).instruction();
-  }
-  async buildWithdrawCollateralInstruction(props) {
-    const { withdrawalAuthority: user, voteAccount, destination, amount } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.bondWithdraw(amountLamports).accountsStrict({
-      validatorBondAccount: validatorBondAccountAddress,
-      withdrawalAuthority: user,
-      destination,
-      systemProgram: SystemProgram.programId
-    }).instruction();
-  }
-  // Build withdraw compensation instruction
-  buildWithdrawCompensationInstruction(props) {
-    const { authority, voteAccount, amount } = props;
-    const [globalState] = this.getGlobalStatePDA();
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.withdrawCompensation(amountLamports).accountsStrict({
-      globalState,
-      validatorBondAccount: validatorBondAccountAddress,
-      reserve: this.config.reserveAddress,
-      authority,
-      systemProgram: SystemProgram.programId
-    }).instruction();
-  }
-  // Build multiple withdraw compensation instructions
-  buildWithdrawCompensationsInstructions(authority, withdrawals) {
-    return Promise.all(
-      withdrawals.map(
-        ({ voteAccount, amount }) => this.buildWithdrawCompensationInstruction({ authority, voteAccount, amount })
-      )
-    );
-  }
-  // Get validator bond account state
-  async getValidatorBondAccount(voteAccount) {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    try {
-      const account = await this.program.account.validatorBondAccount.fetch(validatorBondAccountAddress);
-      return {
-        identity: account.identity.toString(),
-        voteAccount: account.voteAccount.toString(),
-        withdrawalAuthority: account.withdrawalAuthority ? account.withdrawalAuthority.toString() : null,
-        totalWithdrawn: account.totalWithdrawn.toNumber() / LAMPORTS_PER_SOL,
-        lastWithdrawalEpoch: account.lastWithdrawalEpoch.toNumber(),
-        isActive: account.isActive,
-        createdAt: account.createdAt.toNumber() * 1e3,
-        // TODO
-        bump: account.bump
-      };
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get the collateral balance of a validator bond account
-   * @param voteAccount - The vote account public key
-   * @returns The available collateral balance in SOL (excluding rent-exempt amount)
-   */
-  async getValidatorCollateralBalance(voteAccount) {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    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 state
-  async getGlobalState() {
-    const [globalState] = this.getGlobalStatePDA();
-    try {
-      const account = await this.program.account.globalState.fetch(globalState);
-      return {
-        authority: account.authority.toString(),
-        totalValidators: account.totalValidators,
-        totalWithdrawn: account.totalWithdrawn.toNumber() / LAMPORTS_PER_SOL
-      };
-    } catch {
-      return null;
-    }
-  }
-  // Get current epoch
-  async getCurrentEpoch() {
-    const epochInfo = await this.connection.getEpochInfo();
-    return epochInfo.epoch;
-  }
-  // Helper methods for backward compatibility (can be removed if not needed)
-  async initialize(authority) {
-    const authorityPubkey = authority || this.provider.wallet.publicKey;
-    const ix = await this.buildInitializeInstruction({ authority: authorityPubkey });
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-    return tx;
-  }
-  // 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 }
-    );
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-    return tx;
-  }
-  async topUpCollateral(voteAccount, amount, validator) {
-    const userPubkey = validator ?? this.provider.wallet.publicKey;
-    const ix = await this.buildTopUpCollateralInstruction(
-      { user: userPubkey, voteAccount, amount }
-    );
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-    return tx;
-  }
-  async withdrawCollateral(voteAccount, destination, amount, withdrawalAuthority) {
-    const authorityPubkey = withdrawalAuthority ?? this.provider.wallet.publicKey;
-    const ix = await this.buildWithdrawCollateralInstruction(
-      { withdrawalAuthority: authorityPubkey, voteAccount, destination, amount }
-    );
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-    return tx;
-  }
-  async claimCompensation(voteAccount, amount, authority) {
-    const authorityPubkey = authority ?? this.provider.wallet.publicKey;
-    const ix = await this.buildWithdrawCompensationInstruction(
-      { authority: authorityPubkey, voteAccount, amount }
-    );
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      []
-    );
-    return tx;
-  }
-  /**
-   * Get transaction history grouped by epochs
-   * @param voteAccount - 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);
-    const epochMap = /* @__PURE__ */ new Map();
-    for (const item of fullHistory) {
-      if (item.epoch < currentEpoch - 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;
-    }
-    const result = [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
-    return result;
-  }
-  async getHistory(voteAccount, options) {
-    const [ValidatorBondAccount] = this.getValidatorBondPDA(voteAccount);
-    const signatures = await this.connection.getSignaturesForAddress(
-      ValidatorBondAccount,
-      {
-        limit: options?.limit || 1e3,
-        before: options?.before,
-        until: options?.until
-      }
-    );
-    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
-        }
-      );
-      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) {
-        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.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("bondInit");
-                const bondTopUpDiscriminator = this.getInstructionDiscriminator("bondTopUp");
-                const withdrawCompensationDiscriminator = this.getInstructionDiscriminator("withdrawCompensation");
-                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("bondWithdraw");
-                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
-              });
-            }
-          }
-        }
-      } catch (error) {
-        console.error(`Error processing transaction ${sigInfo.signature}:`, error);
-      }
-    }
-    return history.toSorted((a, b) => b.slot - a.slot);
-  }
-  // Helper method to get paginated history
-  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;
-  }
-  getInstructionDiscriminator(instructionName) {
-    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);
-  }
-};
-
-// src/common.ts
-var PROGRAM_ID = "4a3YovKEfm4jWhczCzJciHXL1xVkXWfGQjRCaMft7M4G";
-var RESERVE_ADDRESS = "61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz";
-dotenv.config();
-function loadConfig() {
-  const rpcUrl = process.env.SOLANA_RPC_URL || "https://api.devnet.solana.com";
-  const programId = new PublicKey(
-    PROGRAM_ID
-  );
-  const reserveAddress = new PublicKey(
-    RESERVE_ADDRESS
-  );
-  return {
-    rpcUrl,
-    programId,
-    reserveAddress
-  };
-}
-function loadKeypair(keypairPath) {
-  try {
-    const keypairString = readFileSync(keypairPath, "utf8");
-    const keypairData = JSON.parse(keypairString);
-    return Keypair.fromSecretKey(new Uint8Array(keypairData));
-  } catch (error) {
-    throw new Error(`Failed to load keypair from ${keypairPath}: ${error}`);
-  }
-}
-
-export { BondTransactionType, JBondClient, PROGRAM_ID, RESERVE_ADDRESS, loadConfig, loadKeypair };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map