@jpool/bond-sdk 0.10.6 → 0.11.0-next.12

package/dist/index.mjs

@@ -4735,7 +4735,7 @@ function slotToEpoch(slot, cluster) {
 
 // src/idl/jbond.json
 var jbond_default = {
-  address: "BondQ7KqZreTcW2UbeTNDcLCJQ3aXAtLn2Fm6ftaJDU",
+  address: "Fo17edWRJewZNTRibgx9iTfjywCW6dzS81VwBLmPFVq1",
   metadata: {
     name: "jbond",
     version: "0.2.1",
@@ -4984,6 +4984,50 @@ var jbond_default = {
         }
       ]
     },
+    {
+      name: "bond_lock_funds",
+      docs: [
+        "Locks funds for both the current and upcoming epoch.",
+        "Moves collateral from available to locked state, making it unavailable for withdrawal for the current and next epoch.",
+        "# Errors",
+        "Fails if the validator is not active, or if there are insufficient available funds."
+      ],
+      discriminator: [
+        117,
+        166,
+        195,
+        99,
+        103,
+        45,
+        195,
+        2
+      ],
+      accounts: [
+        {
+          name: "bond_state",
+          writable: true
+        },
+        {
+          name: "validator_bond",
+          writable: true
+        },
+        {
+          name: "bond_token_account",
+          optional: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
     {
       name: "bond_register",
       docs: [
@@ -5096,6 +5140,42 @@ var jbond_default = {
         }
       ]
     },
+    {
+      name: "bond_release_funds",
+      docs: [
+        "Releases locked funds after an epoch ends.",
+        "Moves collateral from locked back to available state, allowing withdrawals.",
+        "# Errors",
+        "Fails if the validator is not active, or if there are insufficient locked funds."
+      ],
+      discriminator: [
+        184,
+        224,
+        14,
+        24,
+        76,
+        14,
+        226,
+        190
+      ],
+      accounts: [
+        {
+          name: "validator_bond",
+          writable: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
     {
       name: "bond_set_withdraw_authority",
       docs: [
@@ -5275,6 +5355,42 @@ var jbond_default = {
         }
       ]
     },
+    {
+      name: "bond_update",
+      docs: [
+        "Transitions locked funds between epochs for a validator bond.",
+        "",
+        "This function should be called at epoch boundaries to update the bond's",
+        "`last_update_epoch` and move the `next_epoch_locked` amount into",
+        "`current_epoch_locked`. It ensures that the update only occurs once per epoch.",
+        "",
+        "# Errors",
+        "Returns [`BondError::InvalidEpoch`] if called more than once in the same epoch,",
+        "or if the system clock cannot be accessed."
+      ],
+      discriminator: [
+        237,
+        102,
+        183,
+        192,
+        94,
+        83,
+        52,
+        82
+      ],
+      accounts: [
+        {
+          name: "validator_bond",
+          writable: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        }
+      ],
+      args: []
+    },
     {
       name: "bond_withdraw",
       docs: [
@@ -5492,80 +5608,6 @@ var jbond_default = {
       ],
       args: []
     },
-    {
-      name: "migrate_bond",
-      docs: [
-        "Migrates validator bond data from legacy structure to new structure."
-      ],
-      discriminator: [
-        107,
-        119,
-        59,
-        110,
-        76,
-        18,
-        37,
-        163
-      ],
-      accounts: [
-        {
-          name: "bond_state",
-          writable: true
-        },
-        {
-          name: "legacy_validator_bond",
-          writable: true
-        },
-        {
-          name: "legacy_vote_account"
-        },
-        {
-          name: "validator_bond",
-          writable: true,
-          pda: {
-            seeds: [
-              {
-                kind: "const",
-                value: [
-                  118,
-                  97,
-                  108,
-                  105,
-                  100,
-                  97,
-                  116,
-                  111,
-                  114,
-                  95,
-                  98,
-                  111,
-                  110,
-                  100
-                ]
-              },
-              {
-                kind: "account",
-                path: "bond_state"
-              },
-              {
-                kind: "account",
-                path: "legacy_vote_account"
-              }
-            ]
-          }
-        },
-        {
-          name: "creator",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
-        }
-      ],
-      args: []
-    },
     {
       name: "session_finish",
       docs: [
@@ -5632,6 +5674,41 @@ var jbond_default = {
           type: "u64"
         }
       ]
+    },
+    {
+      name: "test_set_last_update_epoch",
+      docs: [
+        "NOTE!: This instruction is for testing purposes only.",
+        "It allows direct manipulation of the validator bond's last epoch update.",
+        "This should not be used in production environments."
+      ],
+      discriminator: [
+        215,
+        125,
+        32,
+        8,
+        43,
+        106,
+        194,
+        221
+      ],
+      accounts: [
+        {
+          name: "validator_bond",
+          writable: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        }
+      ],
+      args: [
+        {
+          name: "epoch",
+          type: "u64"
+        }
+      ]
     }
   ],
   accounts: [
@@ -5875,6 +5952,11 @@ var jbond_default = {
       code: 6023,
       name: "BondNotEnabled",
       msg: "Bond is not enabled"
+    },
+    {
+      code: 6024,
+      name: "InvalidEpoch",
+      msg: "Invalid epoch for this operation"
     }
   ],
   types: [
@@ -6257,33 +6339,76 @@ var jbond_default = {
         fields: [
           {
             name: "state",
+            docs: [
+              "The bond state address"
+            ],
             type: "pubkey"
           },
           {
             name: "identity",
+            docs: [
+              "Validator identity pubkey"
+            ],
             type: "pubkey"
           },
           {
             name: "vote_account",
+            docs: [
+              "Validator vote account pubkey"
+            ],
             type: "pubkey"
           },
           {
             name: "creator",
+            docs: [
+              "The bond creator pubkey"
+            ],
             type: "pubkey"
           },
           {
             name: "withdrawal_authority",
+            docs: [
+              "Optional withdrawal authority pubkey (if set, can withdraw on behalf of the validator,",
+              "otherwise only identity can withdraw)"
+            ],
             type: {
               option: "pubkey"
             }
           },
           {
             name: "created_at",
+            docs: [
+              "Bond creation timestamp"
+            ],
             type: "i64"
           },
           {
             name: "bump",
+            docs: [
+              "Bump for the PDA"
+            ],
             type: "u8"
+          },
+          {
+            name: "next_epoch_locked",
+            docs: [
+              "Amount of collateral locked for the next epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "current_epoch_locked",
+            docs: [
+              "Amount of collateral locked for the current epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "last_update_epoch",
+            docs: [
+              "The last epoch when the bond was updated"
+            ],
+            type: "u64"
           }
         ]
       }
@@ -6397,6 +6522,20 @@ var NodeWallet = class {
   }
 };
 var SOL_DECIMALS = Math.log10(LAMPORTS_PER_SOL);
+function lamportsToSol(lamports) {
+  if (typeof lamports === "number") {
+    return Math.abs(lamports) / LAMPORTS_PER_SOL;
+  }
+  let signMultiplier = 1;
+  if (lamports.isNeg()) {
+    signMultiplier = -1;
+  }
+  const absLamports = lamports.abs();
+  const lamportsString = absLamports.toString(10).padStart(10, "0");
+  const splitIndex = lamportsString.length - SOL_DECIMALS;
+  const solString = `${lamportsString.slice(0, splitIndex)}.${lamportsString.slice(splitIndex)}`;
+  return signMultiplier * Number.parseFloat(solString);
+}
 function solToLamports(amount) {
   if (Number.isNaN(amount)) {
     return new BN(0);
@@ -6417,12 +6556,12 @@ function getBondTypeSeed(type) {
 }
 
 // src/client.ts
-var BondClientEnv = /* @__PURE__ */ ((BondClientEnv2) => {
-  BondClientEnv2["DEV"] = "dev";
-  BondClientEnv2["STAGE"] = "stage";
-  BondClientEnv2["PROD"] = "prod";
-  return BondClientEnv2;
-})(BondClientEnv || {});
+var JBondClientEnv = /* @__PURE__ */ ((JBondClientEnv2) => {
+  JBondClientEnv2["DEV"] = "dev";
+  JBondClientEnv2["STAGE"] = "stage";
+  JBondClientEnv2["PROD"] = "prod";
+  return JBondClientEnv2;
+})(JBondClientEnv || {});
 var JBondClient = class _JBondClient {
   constructor(provider, options) {
     this.provider = provider;
@@ -6434,6 +6573,12 @@ var JBondClient = class _JBondClient {
   get history() {
     return new HistoryManager(this);
   }
+  /**
+   * Creates a local instance of `JBondClient` for development and testing.
+   */
+  static local(options) {
+    return new _JBondClient(AnchorProvider.local(), options);
+  }
   /**
    * Creates an instance of `JBondClient` using a provided connection and wallet.
    */
@@ -6545,7 +6690,7 @@ var JBondClient = class _JBondClient {
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
-   * Claim compensation
+   * Claim compensation for a validator
    */
   async claimCompensation(props) {
     const ix = await this.getClaimIx(props);
@@ -6806,6 +6951,35 @@ var JBondClient = class _JBondClient {
     });
     return this.program.methods.bondClaim(solToLamports(amount)).accountsPartial(accounts).instruction();
   }
+  /**
+   * Build claim all compensations instructions
+   */
+  async getClaimAllCompensationsIxs(props) {
+    const ixs = [];
+    const validatorBondBalances = await this.getBondStateValidatorBondBalances(
+      props.bondType,
+      props.name
+    );
+    for (const bond_balance of validatorBondBalances) {
+      const amountToClaim = lamportsToSol(bond_balance.balance);
+      if (amountToClaim <= 0) {
+        this.debug("No balance to claim for validator:", bond_balance.voteAccount.toBase58());
+        continue;
+      }
+      this.debug("Amount to claim:", amountToClaim);
+      const ix = await this.getClaimIx({
+        bondType: props.bondType,
+        name: props.name,
+        amount: amountToClaim,
+        collateralType: props.collateralType,
+        reserve: props.reserve,
+        authority: props.authority,
+        voteAccount: bond_balance.voteAccount
+      });
+      ixs.push(ix);
+    }
+    return ixs;
+  }
   /**
    * Build set withdraw authority instruction
    */
@@ -6834,6 +7008,82 @@ var JBondClient = class _JBondClient {
     const authority = this.provider.wallet?.publicKey;
     return this.program.methods.sessionStart(new import_bn.BN(props.duration)).accountsPartial({ bondState, authority }).instruction();
   }
+  async lockFunds(props) {
+    const ix = await this.getLockFundsIx(props);
+    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
+  }
+  async releaseFunds(props) {
+    const ix = await this.getReleaseFundsIx(props);
+    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
+  }
+  /**
+   * Update epoch locks
+   */
+  async updateEpochLocks(props) {
+    const { bondType, bondName, voteAccount } = props;
+    const ix = await this.getUpdateEpochLocksIx({ bondType, bondName, voteAccount });
+    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
+  }
+  /**
+   * Build update epoch locks instruction
+   */
+  async getUpdateEpochLocksIx(props) {
+    const { bondType, bondName, voteAccount } = props;
+    const [validatorBond, _] = this.pda.validatorBond(bondType, bondName, voteAccount);
+    return this.program.methods.bondUpdate().accountsPartial({ validatorBond }).instruction();
+  }
+  async getTestSetLastUpdateEpochIx(props) {
+    const { bondType, bondName, voteAccount, epoch } = props;
+    const [validatorBond, _] = this.pda.validatorBond(bondType, bondName, voteAccount);
+    return this.program.methods.testSetLastUpdateEpoch(new import_bn.BN(epoch)).accountsPartial({ validatorBond }).instruction();
+  }
+  /**
+   * Build lock funds instruction
+   */
+  async getLockFundsIx(props) {
+    const { bondType, name, voteAccount, amount, withdrawAuthority } = props;
+    const [bondState] = this.pda.bondState(bondType, name);
+    let collateralType = props.collateralType;
+    if (!collateralType) {
+      const bondState2 = await this.getBondState(bondType, name);
+      collateralType = bondState2.collateralType;
+    }
+    const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
+    const accounts = {
+      bondState,
+      validatorBond,
+      payer: withdrawAuthority,
+      bondTokenAccount: null
+    };
+    matchVariant(collateralType, {
+      native: () => {
+      },
+      token: (mint) => {
+        const bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
+        accounts.bondTokenAccount = bondTokenAccount;
+      }
+    });
+    return this.program.methods.bondLockFunds(solToLamports(amount)).accountsPartial(accounts).instruction();
+  }
+  /**
+   * Build release funds instruction
+   */
+  async getReleaseFundsIx(props) {
+    const { bondType, name, voteAccount, amount, withdrawAuthority } = props;
+    const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
+    const accounts = {
+      validatorBond,
+      payer: withdrawAuthority
+    };
+    return this.program.methods.bondReleaseFunds(solToLamports(amount)).accountsPartial(accounts).instruction();
+  }
+  /**
+   * Get available collateral for withdrawal (taking into account locked funds)
+   */
+  async getAvailableCollateral(bondType, bondName, voteAccount) {
+    const validatorBond = await this.getValidatorBond(bondType, bondName, voteAccount);
+    return await this.getValidatorBondBalance(bondType, bondName, voteAccount) - validatorBond.currentEpochLocked.toNumber();
+  }
   /**
    * Get all bond states with total collected collateral
    */
@@ -6891,8 +7141,8 @@ var JBondClient = class _JBondClient {
         if (!accountInfo) {
           return 0;
         }
-        const { data, lamports } = accountInfo;
-        const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
+        const { lamports } = accountInfo;
+        const rentExempt = await this.validatorBondRentExempt();
         return Math.max(0, lamports - rentExempt);
       },
       token: async (mint) => {
@@ -6906,12 +7156,13 @@ var JBondClient = class _JBondClient {
       }
     });
   }
-  /**
-   * Get total collected collateral for a bond state
-   */
-  async getBondStateTotalCollected(bondType, bondName, votes) {
+  async getBondStateValidatorBondBalances(bondType, bondName) {
     const bondState = await this.getBondState(bondType, bondName);
     const collateralType = bondState.collateralType;
+    const validatorBonds = await this.getValidatorBondsForState(bondType, bondName);
+    if (!validatorBonds.length) {
+      return [];
+    }
     const chunk = (arr, n = 100) => {
       const res = [];
       for (let i = 0; i < arr.length; i += n) {
@@ -6921,54 +7172,53 @@ var JBondClient = class _JBondClient {
     };
     return await matchVariant(collateralType, {
       native: async () => {
-        const addresses = votes.map((vote) => {
-          const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
-          return address;
-        });
+        const addresses = validatorBonds.map((vb) => vb.publicKey);
         const accountInfos = await this.connection.getMultipleAccountsInfo(addresses);
-        const balances = await Promise.all(
-          accountInfos.map(async (accountInfo) => {
-            if (!accountInfo) {
-              return 0;
-            }
-            const { lamports } = accountInfo;
-            return lamports;
-          })
-        );
-        return balances.reduce((sum, v) => sum + v, 0);
+        const rentExempt = await this.validatorBondRentExempt();
+        return validatorBonds.map((vb, idx) => ({
+          voteAccount: vb.voteAccount,
+          balance: Math.max(0, (accountInfos[idx]?.lamports ?? 0) - rentExempt)
+        }));
       },
       token: async (mint) => {
-        const tokenAccounts = votes.map((vote) => {
-          const [validatorBondAddress] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
-          return getAssociatedTokenAddressSync(mint, validatorBondAddress, true);
-        });
-        if (tokenAccounts.length === 0) {
-          return 0;
-        }
-        let total = 0n;
-        for (const part of chunk(tokenAccounts, 100)) {
-          const infos = await this.connection.getMultipleAccountsInfo(part).catch(() => []);
-          for (let i = 0; i < infos.length; i++) {
+        const items = validatorBonds.map((vb) => ({
+          voteAccount: vb.voteAccount,
+          tokenAccount: getAssociatedTokenAddressSync(mint, vb.publicKey, true)
+        }));
+        const balances = [];
+        for (const part of chunk(items, 100)) {
+          const infos = await this.connection.getMultipleAccountsInfo(part.map((i) => i.tokenAccount)).catch(() => []);
+          for (let i = 0; i < part.length; i++) {
             const info = infos[i];
-            if (!info) {
-              continue;
-            }
-            if (info.data.length !== ACCOUNT_SIZE) {
+            const voteAccount = part[i].voteAccount;
+            if (!info || info.data.length !== ACCOUNT_SIZE) {
+              balances.push({ voteAccount, balance: 0 });
               continue;
             }
             try {
               const acc = AccountLayout.decode(info.data);
               const raw = BigInt(acc.amount.toString());
-              total += raw;
+              const asNumber = Number(raw);
+              balances.push({
+                voteAccount,
+                balance: Number.isFinite(asNumber) ? asNumber : Number.MAX_SAFE_INTEGER
+              });
             } catch {
+              balances.push({ voteAccount, balance: 0 });
             }
           }
         }
-        const asNumber = Number(total);
-        return Number.isFinite(asNumber) ? asNumber : Number.MAX_SAFE_INTEGER;
+        return balances;
       }
     });
   }
+  /**
+   * Get total collected collateral for a bond state
+   */
+  async getBondStateTotalCollected(bondType, bondName) {
+    const allBalances = await this.getBondStateValidatorBondBalances(bondType, bondName);
+    return allBalances.reduce((sum, vb) => sum + vb.balance, 0);
+  }
   /**
    * Get bond state stats
    * @param state
@@ -6976,21 +7226,25 @@ var JBondClient = class _JBondClient {
    */
   async getBondStateStats(state) {
     const bondType = anchorToBondType(state.bondType);
-    const validatorBonds = await this.getBondValidatorStates(bondType, state.name);
     const totalCollected = await this.getBondStateTotalCollected(
       bondType,
-      state.name,
-      validatorBonds.map((vb) => vb.voteAccount)
+      state.name
     );
     return {
       totalCollected,
       status: this.getBondStateSessionStatus(state)
     };
   }
+  /**
+   * Get validator bond rent exempt amount
+   */
+  validatorBondRentExempt = async () => {
+    return this.connection.getMinimumBalanceForRentExemption(this.program.account.validatorBond.size);
+  };
   /**
    * Get all validator bonds for a given bond state
    */
-  async getBondValidatorStates(bondType, bondName) {
+  async getValidatorBondsForState(bondType, bondName) {
     const [bondState] = this.pda.bondState(bondType, bondName);
     const accounts = await this.program.account.validatorBond.all([
       {
@@ -7033,6 +7287,6 @@ buffer/index.js:
    *)
 */
 
-export { BOND_STATE_SEED, BondClientEnv, BondTransactionType, BondType, CROWDFUNDING_BOND_SEED, ENV_PROGRAM_ID, GLOBAL_STATE_SEED, JBondClient, NodeWallet, STANDARD_BOND_SEED, SessionStatus, VALIDATOR_BOND_SEED };
+export { BOND_STATE_SEED, BondTransactionType, BondType, CROWDFUNDING_BOND_SEED, ENV_PROGRAM_ID, GLOBAL_STATE_SEED, JBondClient, JBondClientEnv, NodeWallet, STANDARD_BOND_SEED, SessionStatus, VALIDATOR_BOND_SEED };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map