@jpool/bond-sdk 0.1.0-next.1 → 0.1.0-next.3

package/dist/index.mjs

@@ -0,0 +1,1254 @@
+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';
+
+// 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: "set_authority",
+      docs: [
+        "Change the bond authority"
+      ],
+      discriminator: [
+        133,
+        250,
+        37,
+        21,
+        110,
+        163,
+        26,
+        121
+      ],
+      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",
+          signer: true,
+          relations: [
+            "global_state"
+          ]
+        },
+        {
+          name: "new_authority"
+        }
+      ],
+      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;
+    }
+  }
+  // Build set authority instruction
+  async buildSetAuthorityInstruction(props) {
+    const [globalState] = this.getGlobalStatePDA();
+    return this.program.methods.setAuthority().accountsStrict({
+      globalState,
+      authority: props.authority,
+      newAuthority: props.newAuthority
+    }).instruction();
+  }
+  /**
+   * 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";
+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