@jpool/bond-sdk 0.9.0-next.8 → 0.9.0-next.9

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 { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';
-import { PublicKey, Transaction, SystemProgram, StakeProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
+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 bs58 from 'bs58';
 
 var __create = Object.create;
@@ -4582,6 +4582,39 @@ var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
   return SessionStatus2;
 })(SessionStatus || {});
 
+// src/utils/enum-utils.ts
+function getVariant(v) {
+  const key = Object.keys(v)[0];
+  return [key, v[key]];
+}
+function variantArgs(payload) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+  if (payload && typeof payload === "object") {
+    const numericKeys = Object.keys(payload).filter((k) => String(+k) === k);
+    if (numericKeys.length) {
+      return numericKeys.sort((a, b) => +a - +b).map((k) => payload[k]);
+    }
+    return [payload];
+  }
+  return [payload];
+}
+function matchVariant(v, handlers) {
+  const [k, data] = getVariant(v);
+  const h = handlers[k];
+  if (!h) {
+    throw new Error(`Unhandled variant: ${k}`);
+  }
+  return h(...variantArgs(data));
+}
+function variantKey(v) {
+  return Object.keys(v)[0];
+}
+function sameVariant(a, b) {
+  return variantKey(a) === variantKey(b);
+}
+
 // src/utils/wallet.ts
 function isVersionedTransaction(tx) {
   return "version" in tx;
@@ -5966,17 +5999,6 @@ var jbond_default = {
             ],
             type: "u64"
           },
-          {
-            name: "status",
-            docs: [
-              "Current status of the bond"
-            ],
-            type: {
-              defined: {
-                name: "BondStatus"
-              }
-            }
-          },
           {
             name: "session_start_ts",
             docs: [
@@ -6001,23 +6023,6 @@ var jbond_default = {
         ]
       }
     },
-    {
-      name: "BondStatus",
-      type: {
-        kind: "enum",
-        variants: [
-          {
-            name: "Active"
-          },
-          {
-            name: "Inactive"
-          },
-          {
-            name: "Pending"
-          }
-        ]
-      }
-    },
     {
       name: "BondType",
       docs: [
@@ -6378,13 +6383,8 @@ var JBondClient = class _JBondClient {
     return this;
   }
   getBondTypeSeed(bondType) {
-    if ("performance" in bondType) {
-      return "performance" /* PerformanceBond */;
-    }
-    if ("crowdfunding" in bondType) {
-      return "crowdfunding" /* CrowdFundingBond */;
-    }
-    throw new Error(`Unknown bond type: ${JSON.stringify(bondType)}`);
+    const [k] = getVariant(bondType);
+    return bondTypeToSeed[k];
   }
   /**
    * Program Derived Addresses (PDAs)
@@ -6539,13 +6539,16 @@ var JBondClient = class _JBondClient {
       reserveTokenAccount: null,
       mint: null
     };
-    if ("token" in props.collateralType) {
-      accounts.reserveTokenAccount = getAssociatedTokenAddressSync(
-        props.collateralType.token[0],
-        props.reserve
-      );
-      accounts.mint = props.collateralType.token[0];
-    }
+    matchVariant(props.collateralType, {
+      native: () => {
+      },
+      token: (mint) => {
+        accounts.reserveTokenAccount = getAssociatedTokenAddressSync(mint, props.reserve);
+        accounts.mint = mint;
+      },
+      stakeAccount: () => {
+      }
+    });
     return this.program.methods.bondInitialize({
       name: props.name,
       bondType: props.bondType,
@@ -6574,7 +6577,7 @@ var JBondClient = class _JBondClient {
       throw new Error("Missing creator");
     }
     const collateralType = (await this.getBondState(bondType, name)).collateralType;
-    const acct = {
+    const accounts = {
       bondState,
       validatorBond,
       identity,
@@ -6586,12 +6589,18 @@ var JBondClient = class _JBondClient {
       bondTokenAccount: null,
       mint: null
     };
-    if ("token" in collateralType) {
-      const mint = collateralType.token[0];
-      const bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-      Object.assign(acct, { mint, bondTokenAccount });
-    }
-    return this.program.methods.bondRegister(bondType, name).accountsPartial(acct).instruction();
+    matchVariant(collateralType, {
+      native: () => {
+      },
+      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();
   }
   async buildTopUpIXs(props) {
     const { bondType, voteAccount, collateral, name } = props;
@@ -6624,19 +6633,23 @@ var JBondClient = class _JBondClient {
       associatedTokenProgram: null,
       stakeProgram: null
     };
-    if ("token" in collateralType) {
-      const mint = collateralType.token[0];
-      accounts.payerTokenAccount = getAssociatedTokenAddressSync(mint, payer);
-      accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-      accounts.tokenProgram = TOKEN_PROGRAM_ID;
-      accounts.associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID;
-    } else if ("stakeAccount" in collateralType) {
-      if (!collateral.stakeAccount) {
-        throw new Error("Missing stakeAccount for stake collateral");
-      }
-      accounts.stakeAccount = collateral.stakeAccount;
-      accounts.stakeProgram = StakeProgram.programId;
-    }
+    matchVariant(collateralType, {
+      native: () => {
+      },
+      token: (mint) => {
+        accounts.payerTokenAccount = getAssociatedTokenAddressSync(mint, payer);
+        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(
       await this.program.methods.bondTopUp(this.lamports(collateral.amount)).accountsPartial(accounts).instruction()
     );
@@ -6664,18 +6677,22 @@ var JBondClient = class _JBondClient {
       tokenProgram: null,
       stakeProgram: null
     };
-    if ("token" in collateralType) {
-      const mint = collateralType.token[0];
-      accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, destination, true);
-      accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-      accounts.tokenProgram = TOKEN_PROGRAM_ID;
-    } else if ("stakeAccount" in collateralType) {
-      if (!withdraw.stakeAccount) {
-        throw new Error("Missing stakeAccount for stake collateral");
-      }
-      accounts.stakeAccount = withdraw.stakeAccount;
-      accounts.stakeProgram = StakeProgram.programId;
-    }
+    matchVariant(collateralType, {
+      native: () => {
+      },
+      token: (mint) => {
+        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) {
@@ -6700,19 +6717,23 @@ var JBondClient = class _JBondClient {
       tokenProgram: null,
       stakeProgram: null
     };
-    if ("token" in collateralType) {
-      const mint = collateralType.token[0];
-      accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
-      accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-      accounts.reserveTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
-      accounts.tokenProgram = TOKEN_PROGRAM_ID;
-    } else if ("stakeAccount" in collateralType) {
-      if (!claim.stakeAccount) {
-        throw new Error("Missing stakeAccount for stake collateral");
-      }
-      accounts.stakeAccount = claim.stakeAccount;
-      accounts.stakeProgram = StakeProgram.programId;
-    }
+    matchVariant(collateralType, {
+      native: () => {
+      },
+      token: (mint) => {
+        accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
+        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(
       accounts
     ).instruction();
@@ -6749,11 +6770,11 @@ var JBondClient = class _JBondClient {
   /**
    * Get all bond states with total collected collateral
    */
-  async getAllBondStates(_bondType) {
+  async getAllBondStates(bondType) {
     const bondStates = [];
     const bondStateAccounts = await this.program.account.bondState.all();
     for (const { account: state } of bondStateAccounts) {
-      if (!("crowdfunding" in state.bondType)) {
+      if (!sameVariant(state.bondType, bondType)) {
         continue;
       }
       const validatorBonds = await this.getValidatorBondsByState(state.bondType, state.name);
@@ -6770,6 +6791,9 @@ var JBondClient = class _JBondClient {
     }
     return bondStates;
   }
+  /**
+   * Get session status for bond state
+   */
   async getBondStateSessionStatus(bondState) {
     const now = Math.floor(Date.now() / 1e3);
     if (bondState.sessionFinishTs.toNumber() > now) {
@@ -6778,6 +6802,7 @@ var JBondClient = class _JBondClient {
       return 1 /* Finished */;
     }
   }
+  /** Get all validator bonds for a given bond state */
   async getValidatorBondsByState(bondType, bondName) {
     const validatorBonds = [];
     const bondStatePda = this.pda.bondState(bondType, bondName)[0];
@@ -6826,20 +6851,35 @@ var JBondClient = class _JBondClient {
     const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
     const bondStateData = await this.getBondState(bondType, bondName);
     const bondStateCollateralType = bondStateData.collateralType;
-    if ("token" in bondStateCollateralType) {
-      const mint = bondStateCollateralType.token[0];
-      const tokenAccount = getAssociatedTokenAddressSync(mint, address, true);
-      const balance = await this.connection.getTokenAccountBalance(tokenAccount);
-      return Number(balance.value.uiAmount ?? 0);
-    }
-    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);
-    const availableBalance = Math.max(0, lamports - rentExempt);
-    return availableBalance;
+    return await matchVariant(bondStateCollateralType, {
+      native: 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 tokenAccount = getAssociatedTokenAddressSync(mint, address, true);
+        try {
+          const balance = await this.connection.getTokenAccountBalance(tokenAccount);
+          return Number(balance.value.uiAmount ?? 0);
+        } catch {
+          return 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);
+      }
+    });
   }
   /**
    * Load stake pool account and cache it if not already cached