@jpool/bond-sdk 0.4.0 → 0.5.0-next.1

package/dist/index.mjs

@@ -1,43 +1,46 @@
-import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { PublicKey, Connection, SystemProgram, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY, Transaction } from '@solana/web3.js';
+import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
+import { PublicKey, Transaction, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY } from '@solana/web3.js';
 import bs58 from 'bs58';
 
 // src/client.ts
-var PROGRAM_ID = new PublicKey("8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr");
-var DEV_PROGRAM_ID = new PublicKey("8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr");
 
-// 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/constants.ts
+var ENV_PROGRAM_ID = {
+  // [BondClientEnv.DEV]: new PublicKey('...'),
+};
 
 // src/idl/jbond.json
 var jbond_default = {
-  address: "8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr",
+  address: "BondQ7KqZreTcW2UbeTNDcLCJQ3aXAtLn2Fm6ftaJDU",
   metadata: {
     name: "jbond",
-    version: "0.1.0",
+    version: "0.2.0",
     spec: "0.1.0",
-    description: "Validator compensation program for boosting APR"
+    description: "Jpool Bond Program"
   },
   instructions: [
     {
-      name: "bond_init",
+      name: "claim",
       docs: [
-        "Register validator and fund initial collateral"
+        "Claims compensation for a validator.",
+        "Transfers funds from the validator's bond account to reserve.",
+        "",
+        "# Arguments",
+        "* `amount` - Amount of compensation to claim (must be positive).",
+        "",
+        "# Errors",
+        "Fails if the authority is invalid, if the validator is not active,",
+        "if the amount is zero, or if there are insufficient funds."
       ],
       discriminator: [
-        220,
+        62,
+        198,
+        214,
+        193,
+        213,
+        159,
         108,
-        156,
-        81,
-        16,
-        185,
-        144,
-        157
+        210
       ],
       accounts: [
         {
@@ -66,7 +69,7 @@ var jbond_default = {
           }
         },
         {
-          name: "validator_bond_account",
+          name: "validator_bond",
           writable: true,
           pda: {
             seeds: [
@@ -91,23 +94,21 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "vote_account"
+                path: "validator_bond.vote_account",
+                account: "ValidatorBond"
               }
             ]
           }
         },
         {
-          name: "identity"
-        },
-        {
-          name: "vote_account"
+          name: "reserve",
+          writable: true
         },
         {
-          name: "creator",
+          name: "authority",
           docs: [
-            "The account creating the bond (pays for account creation and initial collateral)"
+            "Authority that can trigger claims"
           ],
-          writable: true,
           signer: true
         },
         {
@@ -117,97 +118,124 @@ var jbond_default = {
       ],
       args: [
         {
-          name: "initial_collateral",
+          name: "amount",
           type: "u64"
-        },
-        {
-          name: "withdrawal_authority",
-          type: {
-            option: "pubkey"
-          }
         }
       ]
     },
     {
-      name: "bond_top_up",
+      name: "initialize",
       docs: [
-        "Top up collateral for existing validator"
+        "Initializes the global state for the bonding program.",
+        "Sets the authority and reserve account for managing validator bonds.",
+        "",
+        "# Errors",
+        "Fails if the global state account is already initialized or if the payer lacks",
+        "sufficient funds."
       ],
       discriminator: [
-        132,
-        225,
-        254,
-        187,
+        175,
+        175,
+        109,
+        31,
+        13,
         152,
-        162,
-        176,
-        66
+        155,
+        237
       ],
       accounts: [
         {
-          name: "validator_bond_account",
+          name: "global_state",
           writable: true,
           pda: {
             seeds: [
               {
                 kind: "const",
                 value: [
-                  118,
+                  103,
+                  108,
+                  111,
+                  98,
                   97,
                   108,
-                  105,
-                  100,
+                  95,
+                  115,
+                  116,
                   97,
                   116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
+                  101
                 ]
-              },
-              {
-                kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
               }
             ]
           }
         },
         {
-          name: "depositor",
+          name: "authority",
           writable: true,
           signer: true
         },
+        {
+          name: "reserve"
+        },
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
         }
       ],
-      args: [
-        {
-          name: "amount",
-          type: "u64"
-        }
-      ]
+      args: []
     },
     {
-      name: "bond_withdraw",
+      name: "register",
+      docs: [
+        "Registers a new validator with the bonding program.",
+        "Sets up the validator's bond account and deposits initial collateral.",
+        "",
+        "# Arguments",
+        "* `initial_collateral` - Amount of collateral to lock (must be positive).",
+        "* `withdrawal_authority` - Optional key that can withdraw collateral later.",
+        "",
+        "# Errors",
+        "Fails if the validator is already registered, if the vote account is invalid,",
+        "or if the initial collateral transfer fails."
+      ],
       discriminator: [
-        99,
-        64,
-        127,
+        211,
+        124,
+        67,
+        15,
+        211,
+        194,
         178,
-        53,
-        117,
-        70,
-        204
+        240
       ],
       accounts: [
         {
-          name: "validator_bond_account",
+          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",
           writable: true,
           pda: {
             seeds: [
@@ -232,24 +260,24 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
+                path: "vote_account"
               }
             ]
           }
         },
         {
-          name: "withdrawal_authority",
-          writable: true,
-          signer: true
+          name: "identity"
         },
         {
-          name: "destination",
-          writable: true
+          name: "vote_account"
         },
         {
-          name: "epoch_schedule",
-          address: "SysvarEpochSchedu1e111111111111111111111111"
+          name: "creator",
+          docs: [
+            "The account creating the bond (pays for account creation and initial collateral)"
+          ],
+          writable: true,
+          signer: true
         },
         {
           name: "system_program",
@@ -258,71 +286,28 @@ var jbond_default = {
       ],
       args: [
         {
-          name: "amount",
+          name: "initial_collateral",
           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"
+          name: "withdrawal_authority",
+          type: {
+            option: "pubkey"
+          }
         }
-      ],
-      args: []
+      ]
     },
     {
       name: "set_authority",
       docs: [
-        "Change the bond authority"
+        "Sets a new withdrawal authority for a validator's bond account.",
+        "Allows changing who can withdraw collateral in the future.",
+        "",
+        "# Arguments",
+        "* `new_authority` - Optional new authority key (None to restrict to identity).",
+        "",
+        "# Errors",
+        "Fails if the signer is not authorized to change the authority."
       ],
       discriminator: [
         133,
@@ -374,48 +359,105 @@ var jbond_default = {
       args: []
     },
     {
-      name: "withdraw_compensation",
+      name: "top_up",
       docs: [
-        "Withdraw compensation from validator to reserve (oracle only)"
+        "Adds additional collateral to an existing validator's bond.",
+        "Increases the collateral balance, enhancing the validator's stake.",
+        "",
+        "# Arguments",
+        "* `amount` - Amount to add.",
+        "",
+        "# Errors",
+        "Fails if the validator is not active, if the amount is zero,",
+        "or if the transfer of funds fails."
       ],
       discriminator: [
-        10,
-        228,
-        22,
-        213,
-        205,
-        117,
-        181,
-        75
+        236,
+        225,
+        96,
+        9,
+        60,
+        106,
+        77,
+        208
       ],
       accounts: [
         {
-          name: "global_state",
+          name: "validator_bond",
           writable: true,
           pda: {
             seeds: [
               {
                 kind: "const",
                 value: [
-                  103,
-                  108,
-                  111,
-                  98,
+                  118,
                   97,
                   108,
-                  95,
-                  115,
-                  116,
+                  105,
+                  100,
                   97,
                   116,
-                  101
+                  111,
+                  114,
+                  95,
+                  98,
+                  111,
+                  110,
+                  100
                 ]
+              },
+              {
+                kind: "account",
+                path: "validator_bond.vote_account",
+                account: "ValidatorBond"
               }
             ]
           }
         },
         {
-          name: "validator_bond_account",
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "withdraw",
+      docs: [
+        "Withdraws collateral from a validator's bond.",
+        "Decreases the collateral balance, allowing the validator to reclaim funds.",
+        "",
+        "# Arguments",
+        "* `amount` - Amount to withdraw (must not exceed available balance).",
+        "",
+        "# Errors",
+        "Fails if the validator is not active, if the amount is zero,",
+        "if the withdrawal authority is invalid, or if the withdrawal would",
+        "leave insufficient collateral."
+      ],
+      discriminator: [
+        183,
+        18,
+        70,
+        156,
+        148,
+        109,
+        161,
+        34
+      ],
+      accounts: [
+        {
+          name: "validator_bond",
           writable: true,
           pda: {
             seeds: [
@@ -440,22 +482,24 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
+                path: "validator_bond.vote_account",
+                account: "ValidatorBond"
               }
             ]
           }
         },
         {
-          name: "reserve",
+          name: "withdrawal_authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "destination",
           writable: true
         },
         {
-          name: "authority",
-          docs: [
-            "Authority that can trigger claims"
-          ],
-          signer: true
+          name: "epoch_schedule",
+          address: "SysvarEpochSchedu1e111111111111111111111111"
         },
         {
           name: "system_program",
@@ -485,16 +529,16 @@ var jbond_default = {
       ]
     },
     {
-      name: "ValidatorBondAccount",
+      name: "ValidatorBond",
       discriminator: [
-        25,
-        67,
-        241,
-        227,
-        226,
-        104,
-        108,
-        73
+        82,
+        127,
+        243,
+        208,
+        195,
+        42,
+        80,
+        35
       ]
     }
   ],
@@ -619,7 +663,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "new_total",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -643,7 +687,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "remaining_collateral",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -667,11 +711,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "remaining_collateral",
-            type: "u64"
-          },
-          {
-            name: "total_withdrawn",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -692,68 +732,117 @@ var jbond_default = {
         fields: [
           {
             name: "authority",
+            docs: [
+              "The authority allowed to manage the program"
+            ],
             type: "pubkey"
           },
           {
             name: "reserve",
+            docs: [
+              "The reserve vault holding SOL for bonding and compensation"
+            ],
             type: "pubkey"
           },
           {
             name: "total_validators",
-            type: "u32"
+            docs: [
+              "Total number of registered validators"
+            ],
+            type: "u16"
           },
           {
-            name: "total_withdrawn",
+            name: "total_compensation_amount",
+            docs: [
+              "Total compensation amount paid out"
+            ],
             type: "u64"
           },
           {
             name: "bump",
+            docs: [
+              "Bump for the PDA"
+            ],
             type: "u8"
           }
         ]
       }
     },
     {
-      name: "ValidatorBondAccount",
+      name: "ValidatorBond",
       type: {
         kind: "struct",
         fields: [
           {
             name: "identity",
+            docs: [
+              "The validator identity pubkey"
+            ],
             type: "pubkey"
           },
           {
             name: "vote_account",
+            docs: [
+              "The validator vote account pubkey"
+            ],
             type: "pubkey"
           },
           {
             name: "creator",
+            docs: [
+              "Creator of the validator bond account"
+            ],
             type: "pubkey"
           },
           {
             name: "withdrawal_authority",
+            docs: [
+              "Authority allowed to withdraw funds (if None, only identity can withdraw)"
+            ],
             type: {
               option: "pubkey"
             }
           },
           {
-            name: "total_withdrawn",
+            name: "total_compensation_amount",
+            docs: [
+              "Total compensation claimed for the validator"
+            ],
             type: "u64"
           },
           {
-            name: "last_withdrawal_epoch",
+            name: "last_compensation_amount",
+            docs: [
+              "Last compensation amount claimed"
+            ],
             type: "u64"
           },
           {
-            name: "is_active",
-            type: "bool"
+            name: "last_compensation_epoch",
+            docs: [
+              "Last epoch when compensation was claimed"
+            ],
+            type: "u64"
           },
           {
             name: "created_at",
+            docs: [
+              "Timestamp when the bond account was created"
+            ],
             type: "i64"
           },
+          {
+            name: "is_active",
+            docs: [
+              "Whether the validator is currently active"
+            ],
+            type: "bool"
+          },
           {
             name: "bump",
+            docs: [
+              "Bump for the PDA"
+            ],
             type: "u8"
           }
         ]
@@ -765,7 +854,7 @@ var jbond_default = {
         kind: "struct",
         fields: [
           {
-            name: "validator",
+            name: "identity",
             type: "pubkey"
           },
           {
@@ -773,7 +862,7 @@ var jbond_default = {
             type: "pubkey"
           },
           {
-            name: "collateral_amount",
+            name: "initial_collateral",
             type: "u64"
           },
           {
@@ -825,54 +914,65 @@ var NodeWallet = class {
   }
 };
 
+// src/utils/index.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/client.ts
 var BondClientEnv = /* @__PURE__ */ ((BondClientEnv2) => {
   BondClientEnv2["DEV"] = "dev";
+  BondClientEnv2["STAGE"] = "stage";
   BondClientEnv2["PROD"] = "prod";
   return BondClientEnv2;
 })(BondClientEnv || {});
 var JBondClient = class _JBondClient {
-  connection;
-  program;
-  provider;
-  options;
-  constructor(options, wallet) {
-    this.connection = new Connection(options.rpcUrl, "confirmed");
-    this.options = options;
-    this.provider = new AnchorProvider(
-      this.connection,
-      // @ts-expect-error support anonymous
-      wallet ?? { publicKey: PublicKey.default },
-      AnchorProvider.defaultOptions()
-    );
+  constructor(provider, options) {
+    this.provider = provider;
+    this.options = options ?? {};
     this.program = new Program(jbond_default, this.provider);
   }
+  options;
+  program;
   /**
    * Creates an instance of `JBondClient` using a provided connection and wallet.
    */
-  static fromWallet(options, wallet) {
-    return new this(options, wallet);
+  static fromWallet(connection, wallet, options) {
+    return new this(
+      new AnchorProvider(
+        connection,
+        wallet ?? { publicKey: PublicKey.default },
+        AnchorProvider.defaultOptions()
+      ),
+      options
+    );
   }
   /**
    * Creates an instance of `JBondClient` using the provided connection and keypair.
    */
-  static fromKeypair(options, keypair) {
-    return _JBondClient.fromWallet(options, new NodeWallet(keypair));
+  static fromKeypair(connection, keypair, options) {
+    return _JBondClient.fromWallet(connection, new NodeWallet(keypair), options);
   }
   /**
    * Get the current program ID.
    */
   get programId() {
-    return this.options.programId ?? PROGRAM_ID;
+    return this.options.programId ?? this.program.programId;
+  }
+  /**
+   * Get the current connection.
+   */
+  get connection() {
+    return this.provider.connection;
   }
   /**
    * Set the environment.
    */
   env(env) {
-    if (env === "prod" /* PROD */) {
-      return this.configure("programId", PROGRAM_ID);
-    }
-    return this.configure("programId", DEV_PROGRAM_ID);
+    return this.configure("programId", ENV_PROGRAM_ID[env]);
   }
   /**
    * Configure a specific option.
@@ -881,235 +981,215 @@ var JBondClient = class _JBondClient {
     this.options[key] = val;
     return this;
   }
-  // Get PDA for global state
-  getGlobalStatePDA() {
-    return PublicKey.findProgramAddressSync(
-      [Buffer.from("global_state")],
-      this.options.programId ?? this.program.programId
-    );
+  /**
+   * Program Derived Addresses (PDAs)
+   */
+  pda = {
+    globalState: () => {
+      return PublicKey.findProgramAddressSync(
+        [Buffer.from("global_state")],
+        this.programId
+      );
+    },
+    validatorBond: (vote) => {
+      return PublicKey.findProgramAddressSync(
+        [
+          Buffer.from("validator_bond"),
+          new PublicKey(vote).toBuffer()
+        ],
+        this.programId
+      );
+    }
+  };
+  /**
+   * Initialize the program
+   * Default authority is the provider's wallet
+   */
+  async initialize(props) {
+    const ix = await this.buildInitializeInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
   }
-  // Get PDA for validator bond account
-  getValidatorBondPDA(voteAccount) {
-    return PublicKey.findProgramAddressSync(
-      [
-        Buffer.from("validator_bond"),
-        voteAccount.toBuffer()
-      ],
-      this.options.programId ?? this.program.programId
-    );
+  /**
+   * Register a new validator
+   * Default creator is the provider's wallet
+   */
+  async registerValidator(props) {
+    const ix = await this.buildRegisterValidatorInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
   }
-  // Build initialize instruction
+  /**
+   * Top up collateral
+   * Default payer is the provider's wallet
+   */
+  async topUpCollateral(props) {
+    const ix = await this.buildTopUpCollateralInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Withdraw collateral
+   * Default withdrawal authority is the provider's wallet
+   * Default destination is the provider's wallet
+   * @return Transaction signature
+   */
+  async withdrawCollateral(props) {
+    const ix = await this.buildWithdrawCollateralInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Claim compensation
+   * Default authority is the provider's wallet
+   * @return Transaction signature
+   */
+  async claimCompensation(props) {
+    const ix = await this.buildClaimInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Set a new authority for the program
+   * Default authority is the provider's wallet
+   * @return Transaction signature
+   */
+  async setAuthority(props) {
+    const ix = await this.buildSetAuthorityInstruction(props);
+    return await this.provider.sendAndConfirm(new Transaction().add(ix));
+  }
+  /**
+   * Build initialize instruction
+   */
   async buildInitializeInstruction(props) {
-    const [globalState] = this.getGlobalStatePDA();
-    const { authority, reserveAddress } = props;
-    return this.program.methods.initialize().accountsStrict({
+    const [globalState] = this.pda.globalState();
+    const { reserve } = props;
+    const authority = props.authority ?? this.provider.wallet.publicKey;
+    return this.program.methods.initialize().accountsPartial({
       globalState,
       authority,
-      reserve: reserveAddress,
-      systemProgram: SystemProgram.programId
+      reserve
     }).instruction();
   }
-  // Build register validator 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({
+    const { identity, voteAccount, initialCollateral, withdrawalAuthority } = props;
+    const [globalState] = this.pda.globalState();
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(initialCollateral * LAMPORTS_PER_SOL);
+    const creator = props.creator ?? this.provider.wallet.publicKey;
+    return this.program.methods.register(lamports, withdrawalAuthority ?? null).accountsPartial({
       creator,
       globalState,
-      validatorBondAccount: validatorBondAccountAddress,
+      validatorBond,
       identity,
-      voteAccount,
-      systemProgram: SystemProgram.programId
+      voteAccount
     }).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
+  /**
+   * Build top up collateral instruction
+   */
+  async buildTopUpCollateralInstruction(props) {
+    const { voteAccount, amount } = props;
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(amount * LAMPORTS_PER_SOL);
+    const payer = props.payer ?? this.provider.wallet.publicKey;
+    return this.program.methods.topUp(lamports).accountsPartial({
+      validatorBond,
+      payer
     }).instruction();
   }
+  /**
+   * Build withdraw collateral 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,
+    const { voteAccount, amount } = props;
+    const [validatorBond] = this.pda.validatorBond(voteAccount);
+    const lamports = new BN(amount * LAMPORTS_PER_SOL);
+    const withdrawalAuthority = props.withdrawalAuthority ?? this.provider.wallet.publicKey;
+    const destination = props.destination ?? this.provider.wallet.publicKey;
+    return this.program.methods.withdraw(lamports).accountsPartial({
+      validatorBond,
+      withdrawalAuthority,
       epochSchedule: SYSVAR_EPOCH_SCHEDULE_PUBKEY,
-      systemProgram: SystemProgram.programId
+      destination
     }).instruction();
   }
-  // Build withdraw compensation instruction
-  async buildWithdrawCompensationInstruction(props) {
-    const { authority, voteAccount, amount } = props;
-    const [globalState] = this.getGlobalStatePDA();
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    const reserveAddress = (await this.getGlobalState())?.reserveAddress;
-    if (!reserveAddress) {
-      throw new Error("Reserve address is not set in the global state. The program might not be initialized yet.");
+  /**
+   * Build claim compensation instruction
+   */
+  async buildClaimInstruction(props) {
+    const [globalState] = this.pda.globalState();
+    const [validatorBond] = this.pda.validatorBond(props.voteAccount);
+    const lamports = new BN(props.amount * LAMPORTS_PER_SOL);
+    const authority = props.authority ?? this.provider.wallet.publicKey;
+    let reserve = props.reserve;
+    if (!reserve) {
+      const globalStateData = await this.getGlobalState();
+      reserve = globalStateData.reserve;
+      if (!reserve) {
+        throw new Error("Reserve address is not set in the global state. The program might not be initialized yet.");
+      }
     }
-    return this.program.methods.withdrawCompensation(amountLamports).accountsStrict({
+    return this.program.methods.claim(lamports).accountsPartial({
       globalState,
-      validatorBondAccount: validatorBondAccountAddress,
-      reserve: reserveAddress,
-      authority,
-      systemProgram: SystemProgram.programId
+      validatorBond,
+      reserve,
+      authority
     }).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
+  /**
+   * Build set authority instruction
+   */
   async buildSetAuthorityInstruction(props) {
-    const [globalState] = this.getGlobalStatePDA();
+    const [globalState] = this.pda.globalState();
+    const authority = props.authority ?? this.provider.wallet.publicKey;
     return this.program.methods.setAuthority().accountsStrict({
       globalState,
-      authority: props.authority,
+      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)
+   * Fetch global state or throw if not found
    */
-  async getValidatorCollateralBalance(voteAccount) {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
+  async getGlobalState() {
+    const [globalState] = this.pda.globalState();
+    return await this.program.account.globalState.fetch(globalState);
+  }
+  /**
+   * Fetch validator bond data or null if not found
+   * @param vote
+   */
+  async getValidatorBond(vote) {
+    const [address] = this.pda.validatorBond(new PublicKey(vote));
+    return await this.program.account.validatorBond.fetchNullable(address);
+  }
+  /**
+   * Get validator bond account balance (in SOL)
+   * @param vote - Vote account public key
+   * @return Balance in SOL
+   */
+  async getValidatorBondBalance(vote) {
+    const [address] = this.pda.validatorBond(new PublicKey(vote));
+    const accountInfo = await this.connection.getAccountInfo(address);
     if (!accountInfo) {
       return 0;
     }
-    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(
-      accountInfo.data.length
-    );
-    const availableBalance = Math.max(0, accountInfo.lamports - rentExempt);
+    const { data, lamports } = accountInfo;
+    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
+    const availableBalance = Math.max(0, 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,
-        reserveAddress: account.reserve.toString()
-      };
-    } 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(reserveAddress, authority) {
-    const authorityPubkey = authority || this.provider.wallet.publicKey;
-    const ix = await this.buildInitializeInstruction({ authority: authorityPubkey, reserveAddress });
-    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 vote - The vote account to get history for
    * @param epochsCount - Number of recent epochs to return (default: 10)
    * @returns Array of epoch history items sorted by epoch (descending)
    */
-  async getHistoryGroupedByEpochs(voteAccount, epochsCount = 10) {
-    const currentEpoch = await this.getCurrentEpoch();
-    const fullHistory = await this.getFullHistory(voteAccount);
+  async getHistoryGroupedByEpochs(vote, epochsCount = 10) {
+    const epochInfo = await this.connection.getEpochInfo();
+    const fullHistory = await this.getFullHistory(new PublicKey(vote));
     const epochMap = /* @__PURE__ */ new Map();
     for (const item of fullHistory) {
-      if (item.epoch < currentEpoch - epochsCount + 1) {
+      if (item.epoch < epochInfo.epoch - epochsCount + 1) {
         continue;
       }
       if (!epochMap.has(item.epoch)) {
@@ -1134,11 +1214,13 @@ var JBondClient = class _JBondClient {
     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;
+    return [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
   }
-  async getHistory(voteAccount, options) {
-    const [ValidatorBondAccount] = this.getValidatorBondPDA(voteAccount);
+  /**
+   * Get transaction history for a specific validator bond account
+   */
+  async getHistory(vote, options) {
+    const [ValidatorBondAccount] = this.pda.validatorBond(new PublicKey(vote));
     const signatures = await this.connection.getSignaturesForAddress(
       ValidatorBondAccount,
       {
@@ -1186,10 +1268,10 @@ var JBondClient = class _JBondClient {
               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 bondInitDiscriminator = this.getInstructionDiscriminator("register");
+                const bondTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
+                const withdrawCompensationDiscriminator = this.getInstructionDiscriminator("claim");
+                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
                 const amountBytes = dataBuffer.slice(8, 16);
                 const amountBN = new BN(amountBytes, "le");
                 amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
@@ -1234,7 +1316,11 @@ var JBondClient = class _JBondClient {
     }
     return history.toSorted((a, b) => b.slot - a.slot);
   }
-  // Helper method to get paginated history
+  /**
+   * Get full transaction history by paginating through results
+   * @param voteAccount
+   * @param pageSize
+   */
   async getFullHistory(voteAccount, pageSize = 100) {
     const allHistory = [];
     let before;
@@ -1254,6 +1340,11 @@ var JBondClient = class _JBondClient {
     }
     return allHistory;
   }
+  /**
+   * Get instruction discriminator from IDL
+   * @param instructionName
+   * @private
+   */
   getInstructionDiscriminator(instructionName) {
     const instruction = this.program.idl.instructions.find((ix) => ix.name === instructionName);
     if (!instruction) {
@@ -1266,6 +1357,6 @@ var JBondClient = class _JBondClient {
   }
 };
 
-export { BondClientEnv, BondTransactionType, DEV_PROGRAM_ID, JBondClient, PROGRAM_ID };
+export { BondClientEnv, BondTransactionType, ENV_PROGRAM_ID, JBondClient, NodeWallet };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map