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

package/dist/index.mjs

@@ -1,46 +1,43 @@
-import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
-import { PublicKey, Transaction, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY } from '@solana/web3.js';
+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 bs58 from 'bs58';
 
 // src/client.ts
+var PROGRAM_ID = new PublicKey("8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr");
+var DEV_PROGRAM_ID = new PublicKey("8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr");
 
-// src/constants.ts
-var ENV_PROGRAM_ID = {
-  // [BondClientEnv.DEV]: new PublicKey('...'),
-};
+// 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: "BondQ7KqZreTcW2UbeTNDcLCJQ3aXAtLn2Fm6ftaJDU",
+  address: "8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr",
   metadata: {
     name: "jbond",
-    version: "0.2.0",
+    version: "0.1.0",
     spec: "0.1.0",
-    description: "Jpool Bond Program"
+    description: "Validator compensation program for boosting APR"
   },
   instructions: [
     {
-      name: "claim",
+      name: "bond_init",
       docs: [
-        "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."
+        "Register validator and fund initial collateral"
       ],
       discriminator: [
-        62,
-        198,
-        214,
-        193,
-        213,
-        159,
+        220,
         108,
-        210
+        156,
+        81,
+        16,
+        185,
+        144,
+        157
       ],
       accounts: [
         {
@@ -69,7 +66,7 @@ var jbond_default = {
           }
         },
         {
-          name: "validator_bond",
+          name: "validator_bond_account",
           writable: true,
           pda: {
             seeds: [
@@ -94,21 +91,23 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "validator_bond.vote_account",
-                account: "ValidatorBond"
+                path: "vote_account"
               }
             ]
           }
         },
         {
-          name: "reserve",
-          writable: true
+          name: "identity"
         },
         {
-          name: "authority",
+          name: "vote_account"
+        },
+        {
+          name: "creator",
           docs: [
-            "Authority that can trigger claims"
+            "The account creating the bond (pays for account creation and initial collateral)"
           ],
+          writable: true,
           signer: true
         },
         {
@@ -118,124 +117,97 @@ var jbond_default = {
       ],
       args: [
         {
-          name: "amount",
+          name: "initial_collateral",
           type: "u64"
+        },
+        {
+          name: "withdrawal_authority",
+          type: {
+            option: "pubkey"
+          }
         }
       ]
     },
     {
-      name: "initialize",
+      name: "bond_top_up",
       docs: [
-        "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."
+        "Top up collateral for existing validator"
       ],
       discriminator: [
-        175,
-        175,
-        109,
-        31,
-        13,
+        132,
+        225,
+        254,
+        187,
         152,
-        155,
-        237
+        162,
+        176,
+        66
       ],
       accounts: [
         {
-          name: "global_state",
+          name: "validator_bond_account",
           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_account.vote_account",
+                account: "ValidatorBondAccount"
               }
             ]
           }
         },
         {
-          name: "authority",
+          name: "depositor",
           writable: true,
           signer: true
         },
-        {
-          name: "reserve"
-        },
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
         }
       ],
-      args: []
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
     },
     {
-      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."
-      ],
+      name: "bond_withdraw",
       discriminator: [
-        211,
-        124,
-        67,
-        15,
-        211,
-        194,
+        99,
+        64,
+        127,
         178,
-        240
+        53,
+        117,
+        70,
+        204
       ],
       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",
+          name: "validator_bond_account",
           writable: true,
           pda: {
             seeds: [
@@ -260,24 +232,24 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "vote_account"
+                path: "validator_bond_account.vote_account",
+                account: "ValidatorBondAccount"
               }
             ]
           }
         },
         {
-          name: "identity"
+          name: "withdrawal_authority",
+          writable: true,
+          signer: true
         },
         {
-          name: "vote_account"
+          name: "destination",
+          writable: true
         },
         {
-          name: "creator",
-          docs: [
-            "The account creating the bond (pays for account creation and initial collateral)"
-          ],
-          writable: true,
-          signer: true
+          name: "epoch_schedule",
+          address: "SysvarEpochSchedu1e111111111111111111111111"
         },
         {
           name: "system_program",
@@ -286,28 +258,71 @@ var jbond_default = {
       ],
       args: [
         {
-          name: "initial_collateral",
+          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: "withdrawal_authority",
-          type: {
-            option: "pubkey"
+          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: [
-        "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."
+        "Change the bond authority"
       ],
       discriminator: [
         133,
@@ -359,105 +374,48 @@ var jbond_default = {
       args: []
     },
     {
-      name: "top_up",
+      name: "withdraw_compensation",
       docs: [
-        "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."
+        "Withdraw compensation from validator to reserve (oracle only)"
       ],
       discriminator: [
-        236,
-        225,
-        96,
-        9,
-        60,
-        106,
-        77,
-        208
+        10,
+        228,
+        22,
+        213,
+        205,
+        117,
+        181,
+        75
       ],
       accounts: [
         {
-          name: "validator_bond",
+          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.vote_account",
-                account: "ValidatorBond"
               }
             ]
           }
         },
         {
-          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",
+          name: "validator_bond_account",
           writable: true,
           pda: {
             seeds: [
@@ -482,24 +440,22 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "validator_bond.vote_account",
-                account: "ValidatorBond"
+                path: "validator_bond_account.vote_account",
+                account: "ValidatorBondAccount"
               }
             ]
           }
         },
         {
-          name: "withdrawal_authority",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "destination",
+          name: "reserve",
           writable: true
         },
         {
-          name: "epoch_schedule",
-          address: "SysvarEpochSchedu1e111111111111111111111111"
+          name: "authority",
+          docs: [
+            "Authority that can trigger claims"
+          ],
+          signer: true
         },
         {
           name: "system_program",
@@ -529,16 +485,16 @@ var jbond_default = {
       ]
     },
     {
-      name: "ValidatorBond",
+      name: "ValidatorBondAccount",
       discriminator: [
-        82,
-        127,
-        243,
-        208,
-        195,
-        42,
-        80,
-        35
+        25,
+        67,
+        241,
+        227,
+        226,
+        104,
+        108,
+        73
       ]
     }
   ],
@@ -663,7 +619,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "post_balance",
+            name: "new_total",
             type: "u64"
           },
           {
@@ -687,7 +643,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "post_balance",
+            name: "remaining_collateral",
             type: "u64"
           },
           {
@@ -711,7 +667,11 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "post_balance",
+            name: "remaining_collateral",
+            type: "u64"
+          },
+          {
+            name: "total_withdrawn",
             type: "u64"
           },
           {
@@ -732,117 +692,68 @@ 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",
-            docs: [
-              "Total number of registered validators"
-            ],
-            type: "u16"
+            type: "u32"
           },
           {
-            name: "total_compensation_amount",
-            docs: [
-              "Total compensation amount paid out"
-            ],
+            name: "total_withdrawn",
             type: "u64"
           },
           {
             name: "bump",
-            docs: [
-              "Bump for the PDA"
-            ],
             type: "u8"
           }
         ]
       }
     },
     {
-      name: "ValidatorBond",
+      name: "ValidatorBondAccount",
       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_compensation_amount",
-            docs: [
-              "Total compensation claimed for the validator"
-            ],
+            name: "total_withdrawn",
             type: "u64"
           },
           {
-            name: "last_compensation_amount",
-            docs: [
-              "Last compensation amount claimed"
-            ],
+            name: "last_withdrawal_epoch",
             type: "u64"
           },
           {
-            name: "last_compensation_epoch",
-            docs: [
-              "Last epoch when compensation was claimed"
-            ],
-            type: "u64"
+            name: "is_active",
+            type: "bool"
           },
           {
             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"
           }
         ]
@@ -854,7 +765,7 @@ var jbond_default = {
         kind: "struct",
         fields: [
           {
-            name: "identity",
+            name: "validator",
             type: "pubkey"
           },
           {
@@ -862,7 +773,7 @@ var jbond_default = {
             type: "pubkey"
           },
           {
-            name: "initial_collateral",
+            name: "collateral_amount",
             type: "u64"
           },
           {
@@ -914,65 +825,54 @@ 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 {
-  constructor(provider, options) {
-    this.provider = provider;
-    this.options = options ?? {};
+  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()
+    );
     this.program = new Program(jbond_default, this.provider);
   }
-  options;
-  program;
   /**
    * Creates an instance of `JBondClient` using a provided connection and wallet.
    */
-  static fromWallet(connection, wallet, options) {
-    return new this(
-      new AnchorProvider(
-        connection,
-        wallet ?? { publicKey: PublicKey.default },
-        AnchorProvider.defaultOptions()
-      ),
-      options
-    );
+  static fromWallet(options, wallet) {
+    return new this(options, wallet);
   }
   /**
    * Creates an instance of `JBondClient` using the provided connection and keypair.
    */
-  static fromKeypair(connection, keypair, options) {
-    return _JBondClient.fromWallet(connection, new NodeWallet(keypair), options);
+  static fromKeypair(options, keypair) {
+    return _JBondClient.fromWallet(options, new NodeWallet(keypair));
   }
   /**
    * Get the current program ID.
    */
   get programId() {
-    return this.options.programId ?? this.program.programId;
-  }
-  /**
-   * Get the current connection.
-   */
-  get connection() {
-    return this.provider.connection;
+    return this.options.programId ?? PROGRAM_ID;
   }
   /**
    * Set the environment.
    */
   env(env) {
-    return this.configure("programId", ENV_PROGRAM_ID[env]);
+    if (env === "prod" /* PROD */) {
+      return this.configure("programId", PROGRAM_ID);
+    }
+    return this.configure("programId", DEV_PROGRAM_ID);
   }
   /**
    * Configure a specific option.
@@ -981,215 +881,235 @@ var JBondClient = class _JBondClient {
     this.options[key] = val;
     return this;
   }
-  /**
-   * 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));
-  }
-  /**
-   * 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));
-  }
-  /**
-   * 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));
+  // Get PDA for global state
+  getGlobalStatePDA() {
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from("global_state")],
+      this.options.programId ?? this.program.programId
+    );
   }
-  /**
-   * 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));
+  // Get PDA for validator bond account
+  getValidatorBondPDA(voteAccount) {
+    return PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("validator_bond"),
+        voteAccount.toBuffer()
+      ],
+      this.options.programId ?? this.program.programId
+    );
   }
-  /**
-   * Build initialize instruction
-   */
+  // Build initialize instruction
   async buildInitializeInstruction(props) {
-    const [globalState] = this.pda.globalState();
-    const { reserve } = props;
-    const authority = props.authority ?? this.provider.wallet.publicKey;
-    return this.program.methods.initialize().accountsPartial({
+    const [globalState] = this.getGlobalStatePDA();
+    const { authority, reserveAddress } = props;
+    return this.program.methods.initialize().accountsStrict({
       globalState,
       authority,
-      reserve
+      reserve: reserveAddress,
+      systemProgram: SystemProgram.programId
     }).instruction();
   }
-  /**
-   * Build register validator instruction
-   */
+  // Build register validator instruction
   async buildRegisterValidatorInstruction(props) {
-    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({
+    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,
-      validatorBond,
+      validatorBondAccount: validatorBondAccountAddress,
       identity,
-      voteAccount
+      voteAccount,
+      systemProgram: SystemProgram.programId
     }).instruction();
   }
-  /**
-   * 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
+  // 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();
   }
-  /**
-   * Build withdraw collateral instruction
-   */
   async buildWithdrawCollateralInstruction(props) {
-    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,
+    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,
       epochSchedule: SYSVAR_EPOCH_SCHEDULE_PUBKEY,
-      destination
+      systemProgram: SystemProgram.programId
     }).instruction();
   }
-  /**
-   * 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.");
-      }
+  // 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.");
     }
-    return this.program.methods.claim(lamports).accountsPartial({
+    return this.program.methods.withdrawCompensation(amountLamports).accountsStrict({
       globalState,
-      validatorBond,
-      reserve,
-      authority
+      validatorBondAccount: validatorBondAccountAddress,
+      reserve: reserveAddress,
+      authority,
+      systemProgram: SystemProgram.programId
     }).instruction();
   }
-  /**
-   * Build set 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
   async buildSetAuthorityInstruction(props) {
-    const [globalState] = this.pda.globalState();
-    const authority = props.authority ?? this.provider.wallet.publicKey;
+    const [globalState] = this.getGlobalStatePDA();
     return this.program.methods.setAuthority().accountsStrict({
       globalState,
-      authority,
+      authority: props.authority,
       newAuthority: props.newAuthority
     }).instruction();
   }
   /**
-   * Fetch global state or throw if not found
+   * 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 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);
+  async getValidatorCollateralBalance(voteAccount) {
+    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
     if (!accountInfo) {
       return 0;
     }
-    const { data, lamports } = accountInfo;
-    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
-    const availableBalance = Math.max(0, lamports - rentExempt);
+    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,
+        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 vote - The vote account to get history for
+   * @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(vote, epochsCount = 10) {
-    const epochInfo = await this.connection.getEpochInfo();
-    const fullHistory = await this.getFullHistory(new PublicKey(vote));
+  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 < epochInfo.epoch - epochsCount + 1) {
+      if (item.epoch < currentEpoch - epochsCount + 1) {
         continue;
       }
       if (!epochMap.has(item.epoch)) {
@@ -1214,13 +1134,11 @@ var JBondClient = class _JBondClient {
     for (const epochData of epochMap.values()) {
       epochData.balanceChange = epochData.deposits - epochData.withdrawals;
     }
-    return [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
+    const result = [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch);
+    return result;
   }
-  /**
-   * Get transaction history for a specific validator bond account
-   */
-  async getHistory(vote, options) {
-    const [ValidatorBondAccount] = this.pda.validatorBond(new PublicKey(vote));
+  async getHistory(voteAccount, options) {
+    const [ValidatorBondAccount] = this.getValidatorBondPDA(voteAccount);
     const signatures = await this.connection.getSignaturesForAddress(
       ValidatorBondAccount,
       {
@@ -1268,10 +1186,10 @@ var JBondClient = class _JBondClient {
               const dataBuffer = bs58.decode(data);
               if (dataBuffer.length >= 16) {
                 const discriminator = dataBuffer.slice(0, 8);
-                const bondInitDiscriminator = this.getInstructionDiscriminator("register");
-                const bondTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
-                const withdrawCompensationDiscriminator = this.getInstructionDiscriminator("claim");
-                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
+                const 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;
@@ -1316,11 +1234,7 @@ var JBondClient = class _JBondClient {
     }
     return history.toSorted((a, b) => b.slot - a.slot);
   }
-  /**
-   * Get full transaction history by paginating through results
-   * @param voteAccount
-   * @param pageSize
-   */
+  // Helper method to get paginated history
   async getFullHistory(voteAccount, pageSize = 100) {
     const allHistory = [];
     let before;
@@ -1340,11 +1254,6 @@ 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) {
@@ -1357,6 +1266,6 @@ var JBondClient = class _JBondClient {
   }
 };
 
-export { BondClientEnv, BondTransactionType, ENV_PROGRAM_ID, JBondClient, NodeWallet };
+export { BondClientEnv, BondTransactionType, DEV_PROGRAM_ID, JBondClient, PROGRAM_ID };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map