@jpool/bond-sdk 0.9.0-next.11 → 0.9.0-next.13

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { Program, AnchorProvider, BN } from '@coral-xyz/anchor';
 import { getStakePoolAccount, STAKE_POOL_PROGRAM_ID, StakePoolInstruction } from '@solana/spl-stake-pool';
 import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from '@solana/spl-token';
-import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL, StakeProgram } from '@solana/web3.js';
+import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
 import bs58 from 'bs58';
 
 var __create = Object.create;
@@ -4803,7 +4803,7 @@ var HistoryManager = class {
 
 // src/idl/jbond.json
 var jbond_default = {
-  address: "DBuUGWbLz8CkAMQiagMfrQzj8SSg1rHQJWrTSc97HWfR",
+  address: "93BH9J99hQS3YinydR6SVjHuAEECoA9kR1BHwnXeDzQe",
   metadata: {
     name: "jbond",
     version: "0.2.1",
@@ -4959,6 +4959,68 @@ var jbond_default = {
         }
       ]
     },
+    {
+      name: "bond_disable",
+      docs: [
+        "Disables a validator's bond, preventing it from participating further."
+      ],
+      discriminator: [
+        159,
+        156,
+        97,
+        253,
+        70,
+        122,
+        117,
+        129
+      ],
+      accounts: [
+        {
+          name: "bond_state",
+          writable: true
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "bond_state"
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "bond_enable",
+      docs: [
+        "Enables a previously disabled validator's bond."
+      ],
+      discriminator: [
+        133,
+        48,
+        84,
+        9,
+        117,
+        131,
+        164,
+        128
+      ],
+      accounts: [
+        {
+          name: "bond_state",
+          writable: true
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "bond_state"
+          ]
+        }
+      ],
+      args: []
+    },
     {
       name: "bond_initialize",
       docs: [
@@ -5866,6 +5928,16 @@ var jbond_default = {
       code: 6021,
       name: "InvalidArgument",
       msg: "Invalid argument provided"
+    },
+    {
+      code: 6022,
+      name: "BondNotDisabled",
+      msg: "Bond is not disabled"
+    },
+    {
+      code: 6023,
+      name: "BondNotEnabled",
+      msg: "Bond is not enabled"
     }
   ],
   types: [
@@ -6044,6 +6116,14 @@ var jbond_default = {
             ],
             type: "i64"
           },
+          {
+            name: "status",
+            type: {
+              defined: {
+                name: "BondStatus"
+              }
+            }
+          },
           {
             name: "bump",
             docs: [
@@ -6054,6 +6134,20 @@ var jbond_default = {
         ]
       }
     },
+    {
+      name: "BondStatus",
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "Active"
+          },
+          {
+            name: "Disabled"
+          }
+        ]
+      }
+    },
     {
       name: "BondType",
       docs: [
@@ -6189,15 +6283,6 @@ var jbond_default = {
       type: {
         kind: "struct",
         fields: [
-          {
-            name: "bonds",
-            docs: [
-              "List of all registered bonds"
-            ],
-            type: {
-              vec: "pubkey"
-            }
-          },
           {
             name: "authority",
             docs: [
@@ -6221,7 +6306,7 @@ var jbond_default = {
         kind: "struct",
         fields: [
           {
-            name: "bond",
+            name: "state",
             type: "pubkey"
           },
           {
@@ -6242,26 +6327,10 @@ var jbond_default = {
               option: "pubkey"
             }
           },
-          {
-            name: "total_compensation_amount",
-            type: "u64"
-          },
-          {
-            name: "last_compensation_amount",
-            type: "u64"
-          },
-          {
-            name: "last_compensation_epoch",
-            type: "u64"
-          },
           {
             name: "created_at",
             type: "i64"
           },
-          {
-            name: "is_active",
-            type: "bool"
-          },
           {
             name: "bump",
             type: "u8"
@@ -6533,6 +6602,14 @@ var JBondClient = class _JBondClient {
     const ix = await this.buildBondFinishIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
+  async bondEnable(props) {
+    const ix = await this.buildBondEnableIx(props);
+    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
+  }
+  async bondDisable(props) {
+    const ix = await this.buildBondDisableIx(props);
+    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
+  }
   async buildBondGlobalStateInitializeIx(props) {
     const [globalState] = this.pda.globalState();
     const authority = props.authority ?? this.provider.wallet?.publicKey;
@@ -6576,8 +6653,6 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.reserveTokenAccount = getAssociatedTokenAddressSync(mint, props.reserve);
         accounts.mint = mint;
-      },
-      stakeAccount: () => {
       }
     });
     return this.program.methods.bondInitialize({
@@ -6626,9 +6701,6 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
         Object.assign(accounts, { mint, bondTokenAccount: accounts.bondTokenAccount });
-      },
-      stakeAccount: () => {
-        throw new Error("Stake account collateral type is not currently supported");
       }
     });
     return this.program.methods.bondRegister(bondType, name).accountsPartial(accounts).instruction();
@@ -6674,13 +6746,6 @@ var JBondClient = class _JBondClient {
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.tokenProgram = TOKEN_PROGRAM_ID;
         accounts.associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!collateral.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = collateral.stakeAccount;
-        accounts.stakeProgram = StakeProgram.programId;
       }
     });
     instructions.push(
@@ -6717,19 +6782,12 @@ var JBondClient = class _JBondClient {
         accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, destination, true);
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.tokenProgram = TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!withdraw.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = withdraw.stakeAccount;
-        accounts.stakeProgram = StakeProgram.programId;
       }
     });
     return this.program.methods.bondWithdraw(this.lamports(withdraw.amount)).accountsPartial(accounts).instruction();
   }
   async buildClaimIx(props) {
-    const { claim, bondType, name } = props;
+    const { bondType, name } = props;
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, props.voteAccount);
     const reserve = props.reserve ?? (await this.getBondState(bondType, name)).reserve;
@@ -6758,13 +6816,6 @@ var JBondClient = class _JBondClient {
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.reserveTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
         accounts.tokenProgram = TOKEN_PROGRAM_ID;
-      },
-      stakeAccount: () => {
-        if (!claim.stakeAccount) {
-          throw new Error("Missing stakeAccount for stake collateral");
-        }
-        accounts.stakeAccount = claim.stakeAccount;
-        accounts.stakeProgram = StakeProgram.programId;
       }
     });
     return this.program.methods.bondClaim(this.lamports(props.claim.amount)).accountsPartial(
@@ -6793,6 +6844,20 @@ var JBondClient = class _JBondClient {
       authority: this.program.provider.wallet?.publicKey
     }).instruction();
   }
+  async buildBondEnableIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    return this.program.methods.bondEnable().accountsPartial({
+      bondState,
+      authority: this.program.provider.wallet?.publicKey
+    }).instruction();
+  }
+  async buildBondDisableIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    return this.program.methods.bondDisable().accountsPartial({
+      bondState,
+      authority: this.program.provider.wallet?.publicKey
+    }).instruction();
+  }
   /**
    * Fetch global state or throw if not found
    */
@@ -6814,16 +6879,7 @@ var JBondClient = class _JBondClient {
       if (!sameVariant(state.bondType, bondType)) {
         continue;
       }
-      const validatorBonds = await this.getValidatorBondsByState(state.bondType, state.name);
-      const balances = await Promise.all(
-        validatorBonds.map(
-          (vb) => this.getValidatorBondBalance(state.bondType, state.name, vb.voteAccount).then((v) => v ?? 0)
-        )
-      );
-      const bondStateStats = {
-        totalCollected: balances.reduce((sum, v) => sum + v, 0),
-        status: await this.getBondStateSessionStatus(state)
-      };
+      const bondStateStats = await this.getBondStateStats(state.bondType, state.name);
       bondStates.push([state, bondStateStats]);
     }
     return bondStates;
@@ -6906,18 +6962,68 @@ var JBondClient = class _JBondClient {
         } catch {
           return 0;
         }
+      }
+    });
+  }
+  // Get total collected collateral for a bond state
+  async getBondStateTotalCollected(bondType, bondName, votes) {
+    const bondStateData = await this.getBondState(bondType, bondName);
+    const bondStateCollateralType = bondStateData.collateralType;
+    return await matchVariant(bondStateCollateralType, {
+      native: async () => {
+        const addresses = votes.map((vote) => {
+          const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
+          return address;
+        });
+        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);
       },
-      stakeAccount: async () => {
-        const accountInfo = await this.connection.getAccountInfo(address).catch(() => null);
-        if (!accountInfo) {
-          return 0;
-        }
-        const { data, lamports } = accountInfo;
-        const rentExempt = await this.connection.getMinimumBalanceForRentExemption(data.length);
-        return Math.max(0, lamports - rentExempt);
+      token: async (mint) => {
+        const tokenAccounts = votes.map((vote) => {
+          const [validatorBondAddress] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
+          return getAssociatedTokenAddressSync(mint, validatorBondAddress, true);
+        });
+        const accountInfos = await this.connection.getMultipleAccountsInfo(tokenAccounts);
+        const balances = await Promise.all(
+          accountInfos.map(async (accountInfo) => {
+            if (!accountInfo) {
+              return 0;
+            }
+            try {
+              const balance = await this.connection.getTokenAccountBalance(tokenAccounts[accountInfos.indexOf(accountInfo)]);
+              return Number(balance.value.uiAmount ?? 0) * LAMPORTS_PER_SOL;
+            } catch {
+              return 0;
+            }
+          })
+        );
+        return balances.reduce((sum, v) => sum + v, 0);
       }
     });
   }
+  async getBondStateStats(bondType, bondName) {
+    const bondState = await this.getBondState(bondType, bondName);
+    const validatorBonds = await this.getValidatorBondsByState(bondState.bondType, bondState.name);
+    const totalCollected = await this.getBondStateTotalCollected(
+      bondType,
+      bondName,
+      validatorBonds.map((vb) => vb.voteAccount)
+    );
+    const bondStateStats = {
+      totalCollected,
+      status: await this.getBondStateSessionStatus(bondState)
+    };
+    return bondStateStats;
+  }
   /**
    * Load stake pool account and cache it if not already cached
    * @private