@jpool/bond-sdk 0.2.0 → 0.3.0-next.0

package/dist/index.mjs

@@ -1,42 +1,46 @@
-import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { Connection, PublicKey, SystemProgram, LAMPORTS_PER_SOL, SYSVAR_EPOCH_SCHEDULE_PUBKEY, Transaction, Keypair } from '@solana/web3.js';
+import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
+import { PublicKey, LAMPORTS_PER_SOL, Transaction } 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/constants.ts
+var ENV_PROGRAM_ID = {
+  // [BondClientEnv.DEV]: new PublicKey('...'),
+};
 
 // src/idl/jbond.json
 var jbond_default = {
-  address: "8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr",
+  address: "FxKkNnBhadZQuZF7B7Fmh915NenoFyCzwPyZmoVoRdLC",
   metadata: {
     name: "jbond",
     version: "0.1.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: [
         {
@@ -65,7 +69,7 @@ var jbond_default = {
           }
         },
         {
-          name: "validator_bond_account",
+          name: "validator_bond",
           writable: true,
           pda: {
             seeds: [
@@ -90,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
         },
         {
@@ -116,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: [
@@ -231,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",
@@ -257,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,
@@ -373,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: [
@@ -439,22 +482,20 @@ var jbond_default = {
               },
               {
                 kind: "account",
-                path: "validator_bond_account.vote_account",
-                account: "ValidatorBondAccount"
+                path: "validator_bond.vote_account",
+                account: "ValidatorBond"
               }
             ]
           }
         },
         {
-          name: "reserve",
-          writable: true
+          name: "withdrawal_authority",
+          writable: true,
+          signer: true
         },
         {
-          name: "authority",
-          docs: [
-            "Authority that can trigger claims"
-          ],
-          signer: true
+          name: "destination",
+          writable: true
         },
         {
           name: "system_program",
@@ -484,16 +525,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
       ]
     }
   ],
@@ -618,7 +659,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "new_total",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -642,7 +683,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "remaining_collateral",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -666,11 +707,7 @@ var jbond_default = {
             type: "u64"
           },
           {
-            name: "remaining_collateral",
-            type: "u64"
-          },
-          {
-            name: "total_withdrawn",
+            name: "post_balance",
             type: "u64"
           },
           {
@@ -691,68 +728,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"
           }
         ]
@@ -764,7 +850,7 @@ var jbond_default = {
         kind: "struct",
         fields: [
           {
-            name: "validator",
+            name: "identity",
             type: "pubkey"
           },
           {
@@ -772,7 +858,7 @@ var jbond_default = {
             type: "pubkey"
           },
           {
-            name: "collateral_amount",
+            name: "initial_collateral",
             type: "u64"
           },
           {
@@ -824,119 +910,176 @@ 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;
-  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()
-    );
+  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(config, wallet) {
-    return new this(config, wallet);
+  static fromWallet(connection, wallet, options) {
+    return new this(
+      new AnchorProvider(
+        connection,
+        // @ts-expect-error support anonymous
+        wallet ?? { publicKey: PublicKey.default },
+        AnchorProvider.defaultOptions()
+      ),
+      options
+    );
   }
   /**
    * Creates an instance of `JBondClient` using the provided connection and keypair.
    */
-  static fromKeypair(config, keypair) {
-    return _JBondClient.fromWallet(config, new NodeWallet(keypair));
+  static fromKeypair(connection, keypair, options) {
+    return _JBondClient.fromWallet(connection, new NodeWallet(keypair), options);
   }
-  // Get PDA for global state
-  getGlobalStatePDA() {
-    return PublicKey.findProgramAddressSync(
-      [Buffer.from("global_state")],
-      this.program.programId
-    );
+  /**
+   * Get the current program ID.
+   */
+  get programId() {
+    return this.options.programId ?? this.program.programId;
   }
-  // Get PDA for validator bond account
-  getValidatorBondPDA(voteAccount) {
-    return PublicKey.findProgramAddressSync(
-      [
-        Buffer.from("validator_bond"),
-        voteAccount.toBuffer()
-      ],
-      this.program.programId
-    );
+  /**
+   * Get the current connection.
+   */
+  get connection() {
+    return this.provider.connection;
+  }
+  /**
+   * Set the environment.
+   */
+  env(env) {
+    return this.configure("programId", ENV_PROGRAM_ID[env]);
+  }
+  /**
+   * Configure a specific option.
+   */
+  configure(key, val) {
+    this.options[key] = val;
+    return this;
   }
-  // Build initialize instruction
+  /**
+   * Program Derived Addresses (PDAs)
+   */
+  pda = {
+    globalState: () => {
+      return PublicKey.findProgramAddressSync(
+        [Buffer.from("global_state")],
+        this.programId
+      );
+    },
+    validatorBond: (voteAccount) => {
+      return PublicKey.findProgramAddressSync(
+        [
+          Buffer.from("validator_bond"),
+          voteAccount.toBuffer()
+        ],
+        this.programId
+      );
+    }
+  };
+  /**
+   * Build initialize instruction
+   * @param props
+   */
   async buildInitializeInstruction(props) {
-    const [globalState] = this.getGlobalStatePDA();
-    return this.program.methods.initialize().accountsStrict({
+    const [globalState] = this.pda.globalState();
+    const { authority, reserveAddress: reserve } = props;
+    return this.program.methods.initialize().accountsPartial({
       globalState,
-      authority: props.authority,
-      reserve: this.config.reserveAddress,
-      systemProgram: SystemProgram.programId
+      authority,
+      reserve
     }).instruction();
   }
-  // Build register validator instruction
+  /**
+   * Build register validator instruction
+   * @param props
+   */
   async buildRegisterValidatorInstruction(props) {
     const { creator, identity, voteAccount, initialCollateral, withdrawalAuthority } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
     const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
     if (accountInfo) {
       throw new Error("Validator bond account already exists");
     }
-    const [globalState] = this.getGlobalStatePDA();
+    const [globalState] = this.pda.globalState();
     const collateralLamports = new BN(initialCollateral * LAMPORTS_PER_SOL);
-    return this.program.methods.bondInit(collateralLamports, withdrawalAuthority ?? null).accountsStrict({
+    return this.program.methods.register(collateralLamports, withdrawalAuthority ?? null).accountsPartial({
       creator,
       globalState,
-      validatorBondAccount: validatorBondAccountAddress,
+      validatorBond: validatorBondAccountAddress,
       identity,
-      voteAccount,
-      systemProgram: SystemProgram.programId
+      voteAccount
     }).instruction();
   }
-  // Build top up collateral instruction
+  /**
+   * Build top up collateral instruction
+   * @param props
+   */
   buildTopUpCollateralInstruction(props) {
     const { user, voteAccount, amount } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
     const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.bondTopUp(amountLamports).accountsStrict({
-      validatorBondAccount: validatorBondAccountAddress,
-      depositor: user,
-      systemProgram: SystemProgram.programId
+    return this.program.methods.topUp(amountLamports).accountsPartial({
+      validatorBond: validatorBondAccountAddress,
+      payer: user
     }).instruction();
   }
   async buildWithdrawCollateralInstruction(props) {
     const { withdrawalAuthority: user, voteAccount, destination, amount } = props;
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
     const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.bondWithdraw(amountLamports).accountsStrict({
-      validatorBondAccount: validatorBondAccountAddress,
+    return this.program.methods.withdraw(amountLamports).accountsPartial({
+      validatorBond: validatorBondAccountAddress,
       withdrawalAuthority: user,
-      destination,
-      epochSchedule: SYSVAR_EPOCH_SCHEDULE_PUBKEY,
-      systemProgram: SystemProgram.programId
+      destination
     }).instruction();
   }
-  // Build withdraw compensation instruction
-  buildWithdrawCompensationInstruction(props) {
+  /**
+   * Build withdraw compensation instruction
+   * @param props
+   */
+  async buildWithdrawCompensationInstruction(props) {
     const { authority, voteAccount, amount } = props;
-    const [globalState] = this.getGlobalStatePDA();
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+    const [globalState] = this.pda.globalState();
+    const [validatorBondAccountAddress] = this.pda.validatorBond(voteAccount);
     const amountLamports = new BN(amount * LAMPORTS_PER_SOL);
-    return this.program.methods.withdrawCompensation(amountLamports).accountsStrict({
+    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(amountLamports).accountsPartial({
       globalState,
-      validatorBondAccount: validatorBondAccountAddress,
-      reserve: this.config.reserveAddress,
-      authority,
-      systemProgram: SystemProgram.programId
+      validatorBond: validatorBondAccountAddress,
+      reserve: reserveAddress,
+      authority
     }).instruction();
   }
-  // Build multiple withdraw compensation instructions
+  /**
+   * Build multiple withdraw compensation instructions
+   * @param authority
+   * @param withdrawals
+   */
   buildWithdrawCompensationsInstructions(authority, withdrawals) {
     return Promise.all(
       withdrawals.map(
@@ -944,9 +1087,12 @@ var JBondClient = class _JBondClient {
       )
     );
   }
-  // Get validator bond account state
-  async getValidatorBondAccount(voteAccount) {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+  /**
+   * Get validator bond account state
+   * @param vote
+   */
+  async getValidatorBond(vote) {
+    const [validatorBondAccountAddress] = this.pda.validatorBond(vote);
     try {
       const account = await this.program.account.validatorBondAccount.fetch(validatorBondAccountAddress);
       return {
@@ -957,16 +1103,18 @@ var JBondClient = class _JBondClient {
         lastWithdrawalEpoch: account.lastWithdrawalEpoch.toNumber(),
         isActive: account.isActive,
         createdAt: account.createdAt.toNumber() * 1e3,
-        // TODO
+        // Convert i64 Unix seconds (BN) to JS milliseconds
         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();
     return this.program.methods.setAuthority().accountsStrict({
       globalState,
       authority: props.authority,
@@ -975,11 +1123,11 @@ var JBondClient = class _JBondClient {
   }
   /**
    * Get the collateral balance of a validator bond account
-   * @param voteAccount - The vote account public key
+   * @param vote - The vote account public key
    * @returns The available collateral balance in SOL (excluding rent-exempt amount)
    */
-  async getValidatorCollateralBalance(voteAccount) {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount);
+  async getValidatorCollateralBalance(vote) {
+    const [validatorBondAccountAddress] = this.pda.validatorBond(vote);
     const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress);
     if (!accountInfo) {
       return 0;
@@ -990,34 +1138,38 @@ var JBondClient = class _JBondClient {
     const availableBalance = Math.max(0, accountInfo.lamports - rentExempt);
     return availableBalance / LAMPORTS_PER_SOL;
   }
-  // Get global state state
+  /**
+   * Get global 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;
-    }
+    const [globalState] = this.pda.globalState();
+    const account = await this.program.account.globalState.fetch(globalState);
+    return {
+      authority: account.authority.toString(),
+      totalValidators: account.totalValidators,
+      totalCompensationAmount: account.totalCompensationAmount.toNumber() / LAMPORTS_PER_SOL,
+      reserveAddress: account.reserve.toString()
+    };
   }
-  // Get current epoch
+  /**
+   * 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(
+  /**
+   * Helper methods for backward compatibility (can be removed if not needed)
+   * @param props
+   */
+  async initialize(props) {
+    const { reserveAddress } = props;
+    const authority = props.authority ?? this.provider.wallet.publicKey;
+    const ix = await this.buildInitializeInstruction({ reserveAddress, authority });
+    return 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) {
@@ -1025,44 +1177,40 @@ var JBondClient = class _JBondClient {
     const ix = await this.buildRegisterValidatorInstruction(
       { creator: identityPubkey, identity: identityPubkey, voteAccount, initialCollateral, withdrawalAuthority }
     );
-    const tx = await this.provider.sendAndConfirm(
+    return 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(
+    return 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(
+    return 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(
+    return await this.provider.sendAndConfirm(
       new Transaction().add(ix),
       []
     );
-    return tx;
   }
   /**
    * Get transaction history grouped by epochs
@@ -1100,11 +1248,10 @@ 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);
+    const [ValidatorBondAccount] = this.pda.validatorBond(voteAccount);
     const signatures = await this.connection.getSignaturesForAddress(
       ValidatorBondAccount,
       {
@@ -1137,7 +1284,7 @@ var JBondClient = class _JBondClient {
         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)) {
+          if ("programId" in instruction && instruction.programId.equals(this.options.programId ?? this.program.programId)) {
             const ixData = instruction;
             if ("parsed" in ixData && ixData.parsed) {
               continue;
@@ -1200,7 +1347,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;
@@ -1220,6 +1371,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) {
@@ -1232,33 +1388,6 @@ var JBondClient = class _JBondClient {
   }
 };
 
-// src/common.ts
-var PROGRAM_ID = "8vrqsFHnDdjMYMwahytRzmmYgRqCMmka8X6DJUXGQzWr";
-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 };
+export { BondClientEnv, BondTransactionType, ENV_PROGRAM_ID, JBondClient, NodeWallet };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map