@jpool/bond-cli 1.2.0-next.0 → 1.2.0-next.2

package/README.md

@@ -52,7 +52,7 @@ Example:
 Add additional collateral to an existing validator bond.
 
 ```bash
-pnpm jbond topup-collateral <vote-account> <amount> -k <path>
+pnpm jbond topup <vote-account> <amount> -k <path>
 
 Arguments:
   vote-account          Vote account public key
@@ -63,15 +63,15 @@ Options:
   -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
 
 Example:
-  pnpm jbond topup-collateral 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 50 -c mainnet-beta
+  pnpm jbond topup 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 50 -c mainnet-beta
 ```
 
 ### Withdraw Collateral
 
-Withdraw collateral from validator bond account.
+Withdraw collateral from a validator bond account to a specified destination address.
 
 ```bash
-pnpm jbond withdraw-collateral <vote-account> <destination> <amount> [options]
+pnpm jbond withdraw <vote-account> <destination> <amount> [options]
 
 Arguments:
   vote-account          Vote account public key
@@ -83,13 +83,42 @@ Options:
   -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
 
 Example:
-  pnpm jbond withdraw-collateral 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 3K2coMGaZhrSkyF52wUBUXBeRBRpGLnmB3znzLRKjgiP 25 -c mainnet-beta
+  pnpm jbond withdraw 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 3K2coMGaZhrSkyF52wUBUXBeRBRpGLnmB3znzLRKjgiP 25 -c mainnet-beta
 ```
 
 **Requirements**:
 
 Only the validator identity or withdrawal authority can execute withdrawals. The validator bond account must have sufficient collateral
 
+### Set Withdrawal Authority
+
+Set or update the withdrawal authority for a validator bond account. This allows delegating withdrawal permissions to another address.
+
+```bash
+pnpm jbond set-withdraw-authority <vote-account> [options]
+
+Arguments:
+  vote-account          Vote account public key
+
+Options:
+  -k, --keypair <path>  Path to keypair file (default: ~/.config/solana/id.json)
+  -w, --new-authority <pubkey>  New withdrawal authority (omit to remove authority)
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Examples:
+  # Set a withdrawal authority
+  pnpm jbond set-withdraw-authority 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu -w 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin -c mainnet-beta
+
+  # Remove withdrawal authority (revert to identity-only)
+  pnpm jbond set-withdraw-authority 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu -c mainnet-beta
+```
+
+**Requirements**:
+
+- Only the validator identity can set or update the withdrawal authority
+- When a withdrawal authority is set, only that authority (or validator identity) can withdraw collateral
+- Omitting the `--new-authority` option removes the withdrawal authority, reverting to identity-only withdrawals
+
 ### Claim Compensation
 
 Claim compensation from a validator's collateral to the reserve (authority only).
@@ -195,7 +224,7 @@ pnpm jbond register-validator GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 100
 pnpm jbond validator-info GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD -c mainnet-beta
 
 # 4. Top up with additional 50 SOL
-pnpm jbond topup-collateral GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 50 -c mainnet-beta
+pnpm jbond topup GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 50 -c mainnet-beta
 ```
 
 ### Authority Operations
@@ -231,4 +260,4 @@ Common errors and solutions:
 ### `Account already in use`
 
 - The validator is already registered
-- Use `topup-collateral` to add more funds instead
+- Use `topup` to add more funds instead

package/dist/cli.js

@@ -5,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -21,8 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  parseCollateralType: () => parseCollateralType
+});
+module.exports = __toCommonJS(cli_exports);
 var import_web32 = require("@solana/web3.js");
 var import_chalk = __toESM(require("chalk"));
 var import_commander = require("commander");
@@ -81,10 +91,10 @@ function resolveKeypair(path) {
 }
 
 // package.json
-var version = "1.1.0";
+var version = "1.2.0-next.1";
 
 // src/cli.ts
-import_commander.program.name("jbond").description("CLI to interact with the JPool Bond program").version(process.env.VERSION ?? version).allowExcessArguments(false).option("-c, --cluster <CLUSTER>", "Solana cluster or RPC URL").option("-k, --keypair <KEYPAIR>", "Filepath to Solana keypair").hook("preAction", async (command) => {
+import_commander.program.name("jbond").description("CLI to interact with the JPool Bond program").version(process.env.VERSION ?? version).allowExcessArguments(false).option("-c, --cluster <CLUSTER>", "Solana cluster or RPC URL").option("-k, --keypair <KEYPAIR>", "Filepath to Solana keypair").option("-b, --bond-type <TYPE>", "Bond type: performance | crowdfunding", "performance").option("-n , --bond-name <name>", "Bond name").hook("preAction", async (command) => {
   const opts = command.opts();
   const { provider, client } = initContext(opts);
   console.log(import_chalk.default.dim(`# Version: ${command.version()}`));
@@ -95,50 +105,32 @@ import_commander.program.name("jbond").description("CLI to interact with the JPo
 }).hook("postAction", (_c) => {
   process.exit();
 });
-import_commander.program.command("info").description("Get global state information").action(async () => {
+import_commander.program.command("global-initialize").description("Initialize global state").option("-w, --authority <pubkey>", "Authority (defaults to signer)").action(async (opts) => {
+  const spinner = (0, import_ora.default)("Initializing global state...").start();
   const { client, provider } = useContext();
   try {
-    const state = await client.getGlobalState();
-    if (!state) {
-      console.log(import_chalk.default.yellow("Global state not initialized"));
-      return;
-    }
-    console.log(import_chalk.default.cyan("====== Global State: ======\n"));
-    console.log(import_chalk.default.white(`  Authority: ${state.authority}`));
-    console.log(import_chalk.default.white(`  Reserve: ${state.reserve}`));
-    console.log(import_chalk.default.white(`  Total Validators: ${state.totalValidators}`));
-    console.log(import_chalk.default.white(`  Total Compensation Amount: ${state.totalCompensationAmount.toString()}`));
-    const epochInfo = await provider.connection.getEpochInfo();
-    console.log(import_chalk.default.white(`  Current Epoch: ${epochInfo.epoch}`));
-    console.log(import_chalk.default.cyan("\n====== Validators: ======\n"));
-    const bonds = await client.program.account.validatorBond.all();
-    const publicKeys = bonds.map((b) => b.publicKey);
-    const bondAccounts = await provider.connection.getMultipleAccountsInfo(publicKeys);
-    const bondBalances = bondAccounts.map((acc) => acc?.lamports ?? 0);
-    if (bonds.length === 0) {
-      console.log(import_chalk.default.dim("No validators found"));
-    } else {
-      bonds.forEach((b, i) => {
-        console.log(import_chalk.default.magenta(prettyJson({
-          balance: `${bondBalances[i] / import_web32.LAMPORTS_PER_SOL} SOL`,
-          ...b
-        })));
-      });
-    }
+    const authority = opts.authority ? new import_web32.PublicKey(opts.authority) : provider.wallet.publicKey;
+    const tx = await client.globalInitialize({ authority });
+    spinner.succeed(import_chalk.default.green("Global state initialized successfully!"));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+    console.log(import_chalk.default.gray(`Authority: ${authority.toString()}`));
   } catch (error) {
-    console.error(import_chalk.default.red(`Failed to get global state info: ${error}`));
+    spinner.fail(import_chalk.default.red(`Failed to initialize global state: ${error}`));
     process.exit(1);
   }
 });
-import_commander.program.command("initialize").description("Initialize the global state and reserve vault").requiredOption("-r, --reserve <address>", "Reserve vault address").option("-w, --claim-authority <pubkey>", "Claim authority (defaults to signer)").action(async (opts) => {
-  const spinner = (0, import_ora.default)("Initializing global state...").start();
+import_commander.program.command("initialize").description("Initialize specific bond project").requiredOption("-r, --reserve <address>", "Reserve vault address").requiredOption("-t, --collateral <type>", "Collateral type (sol | tokenMint:<address> | stakeAccount)").option("-w, --claim-authority <pubkey>", "Claim authority (defaults to signer)").action(async (opts) => {
+  const spinner = (0, import_ora.default)("Initializing bond project...").start();
   const { client } = useContext();
   const reserve = new import_web32.PublicKey(opts.reserve);
   const authority = opts.claimAuthority ? new import_web32.PublicKey(opts.claimAuthority) : void 0;
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const collateralType = parseCollateralType(opts.collateral);
+  const bondName = import_commander.program.opts().bondName;
+  console.log(import_chalk.default.gray(`Collateral Type: ${JSON.stringify(collateralType)}`));
   try {
-    const tx = await client.initialize({ reserve, authority });
+    await client.bondInitialize({ bondType, name: bondName, authority, collateralType, reserve });
     spinner.succeed(import_chalk.default.green(`Bond program initialized successfully!`));
-    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
     console.log(import_chalk.default.gray(`Reserve address: ${reserve.toString()}`));
   } catch (error) {
     spinner.fail(import_chalk.default.red(`Failed to initialize bond program: ${error}`));
@@ -147,37 +139,46 @@ import_commander.program.command("initialize").description("Initialize the globa
 import_commander.program.command("register-validator").description("Register validator and fund initial collateral").argument("<vote-account>", "Vote account public key").argument("<amount>", "Initial collateral amount in SOL").action(async (voteAccountStr, amount) => {
   const spinner = (0, import_ora.default)("Registering validator...").start();
   const { keypair, client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
     const initialCollateral = Number.parseFloat(amount);
-    if (Number.isNaN(initialCollateral) || initialCollateral <= 0) {
+    if (Number.isNaN(initialCollateral) || initialCollateral < 0) {
       throw new Error("Invalid collateral amount");
     }
-    const tx = await client.registerValidator({
+    await client.registerValidator({
+      bondType,
+      name: bondName,
       voteAccount,
-      initialCollateral,
       identity: keypair.publicKey
     });
     spinner.succeed(import_chalk.default.green(`Validator registered successfully!`));
-    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
-    console.log(import_chalk.default.gray(`Initial collateral: ${initialCollateral} SOL`));
+    console.log(import_chalk.default.gray(`Initial collateral (ignored by register): ${initialCollateral} SOL`));
     console.log(import_chalk.default.gray(`Validator: ${keypair.publicKey.toString()}`));
     console.log(import_chalk.default.gray(`Vote Account: ${voteAccountStr}`));
   } catch (error) {
     spinner.fail(import_chalk.default.red(`Failed to register validator: ${error}`));
   }
 });
-import_commander.program.command("topup-collateral").description("Top up collateral for existing validator").argument("<vote-account>", "Vote account public key").argument("<amount>", "Amount to top up in SOL").action(async (voteAccountStr, amount) => {
+import_commander.program.command("topup").description("Top up collateral for validator bond account").argument("<vote-account>", "Vote account public key").argument("<amount>", "Amount to top up in SOL").action(async (voteAccountStr, amount) => {
   const spinner = (0, import_ora.default)("Topping up collateral...").start();
   const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
     const topUpAmount = Number.parseFloat(amount);
     if (Number.isNaN(topUpAmount) || topUpAmount <= 0) {
       throw new Error("Invalid top-up amount");
     }
-    const signature = await client.topUpCollateral({ voteAccount, amount: topUpAmount });
-    spinner.succeed(import_chalk.default.green(`Collateral topped up successfully!`));
+    const signature = await client.topUpCollateral({
+      bondType,
+      name: bondName,
+      voteAccount,
+      collateral: { amount: topUpAmount }
+    });
+    spinner.succeed(import_chalk.default.green(`Collateral topped up successfully for bond type ${import_commander.program.opts().bondType}!`));
     console.log(import_chalk.default.gray(`Signature: ${signature}`));
     console.log(import_chalk.default.gray(`Top-up amount: ${topUpAmount} SOL`));
   } catch (error) {
@@ -185,9 +186,11 @@ import_commander.program.command("topup-collateral").description("Top up collate
     process.exit(1);
   }
 });
-import_commander.program.command("withdraw-collateral").description("Withdraw collateral from validator bond account").argument("<vote-account>", "Vote account public key").argument("<destination>", "Destination address for withdrawn funds").argument("<amount>", "Amount to withdraw in SOL").action(async (voteAccountStr, destinationStr, amount) => {
+import_commander.program.command("withdraw").description("Withdraw collateral from validator bond account").argument("<vote-account>", "Vote account public key").argument("<destination>", "Destination address for withdrawn funds").argument("<amount>", "Amount to withdraw in SOL").action(async (voteAccountStr, destinationStr, amount) => {
   const spinner = (0, import_ora.default)("Withdrawing collateral...").start();
   const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
     const destination = new import_web32.PublicKey(destinationStr);
@@ -195,11 +198,17 @@ import_commander.program.command("withdraw-collateral").description("Withdraw co
     if (Number.isNaN(withdrawAmount) || withdrawAmount <= 0) {
       throw new Error("Invalid withdrawal amount");
     }
-    const bondAccount = await client.getValidatorBond(voteAccount);
-    if (!bondAccount) {
+    const bond = await client.getValidatorBond(bondType, bondName, voteAccount);
+    if (!bond) {
       throw new Error("Validator bond account not found");
     }
-    const tx = await client.withdrawCollateral({ voteAccount, destination, amount: withdrawAmount });
+    const tx = await client.withdrawCollateral({
+      bondType,
+      name: bondName,
+      voteAccount,
+      destination,
+      withdraw: { amount: withdrawAmount }
+    });
     spinner.succeed(import_chalk.default.green(`Collateral withdrawn successfully!`));
     console.log(import_chalk.default.gray(`Transaction: ${tx}`));
     console.log(import_chalk.default.gray(`Amount withdrawn: ${withdrawAmount} SOL`));
@@ -212,6 +221,8 @@ import_commander.program.command("withdraw-collateral").description("Withdraw co
 import_commander.program.command("claim-compensation").description("Claim compensation from validator to reserve").argument("<vote-account>", "Vote account public key").argument("<amount>", "Amount to withdraw in SOL").action(async (voteAccountStr, amount) => {
   const spinner = (0, import_ora.default)("Claiming compensation...").start();
   const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
     const withdrawAmount = Number.parseFloat(amount);
@@ -219,8 +230,12 @@ import_commander.program.command("claim-compensation").description("Claim compen
       throw new Error("Invalid withdrawal amount");
     }
     const tx = await client.claimCompensation({
+      bondType,
+      name: bondName,
       voteAccount,
-      amount: withdrawAmount
+      claim: {
+        amount: withdrawAmount
+      }
     });
     spinner.succeed(import_chalk.default.green(`Compensation withdrawn successfully!`));
     console.log(import_chalk.default.gray(`Transaction: ${tx}`));
@@ -232,31 +247,31 @@ import_commander.program.command("claim-compensation").description("Claim compen
 });
 import_commander.program.command("validator-info").description("Get validator bond account information").argument("<vote-account>", "Vote account public key").option("-v, --validator <pubkey>", "Validator public key (optional, defaults to current keypair)").action(async (voteAccountStr) => {
   const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
-    const [validatorBondAddress] = client.pda.validatorBond(voteAccount);
+    const [validatorBondAddress] = client.pda.validatorBond(bondType, bondName, voteAccount);
     console.log(import_chalk.default.gray(`Validator Bond Address: ${validatorBondAddress.toString()}`));
-    const state = await client.getValidatorBond(
-      voteAccount
-    );
-    if (!state) {
+    const bond = await client.getValidatorBond(bondType, bondName, voteAccount);
+    if (!bond) {
       console.log(import_chalk.default.yellow("Validator bond account not found"));
       return;
     }
     console.log(import_chalk.default.cyan("\nValidator Bond Account Information:"));
-    console.log(import_chalk.default.white(`  Validator: ${state.identity}`));
-    console.log(import_chalk.default.white(`  Vote Account: ${state.voteAccount}`));
-    if (state.withdrawalAuthority) {
-      console.log(import_chalk.default.white(`  Withdrawal Authority: ${state.withdrawalAuthority}`));
+    console.log(import_chalk.default.white(`  Validator: ${bond.identity}`));
+    console.log(import_chalk.default.white(`  Vote Account: ${bond.voteAccount}`));
+    if (bond.withdrawalAuthority) {
+      console.log(import_chalk.default.white(`  Withdrawal Authority: ${bond.withdrawalAuthority}`));
     } else {
       console.log(import_chalk.default.white(`  Withdrawal Authority: Not set (identity only)`));
     }
     console.log(
       import_chalk.default.white(
-        `  Active: ${state.isActive ? import_chalk.default.green("Yes") : import_chalk.default.red("No")}`
+        `  Active: ${bond.isActive ? import_chalk.default.green("Yes") : import_chalk.default.red("No")}`
       )
     );
-    console.log(import_chalk.default.white(`  Created At: ${state.createdAt}`));
+    console.log(import_chalk.default.white(`  Created At: ${bond.createdAt}`));
   } catch (error) {
     console.error(import_chalk.default.red(`Failed to get validator info: ${error}`));
     process.exit(1);
@@ -265,9 +280,11 @@ import_commander.program.command("validator-info").description("Get validator bo
 import_commander.program.command("set-withdraw-authority").description("Set or update withdrawal authority for validator bond").argument("<vote-account>", "Vote account public key").option("-w, --new-authority <pubkey>", "New withdrawal authority (omit to remove authority)").action(async (voteAccountStr, options) => {
   const spinner = (0, import_ora.default)("Setting withdrawal authority...").start();
   const { client, keypair } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     const voteAccount = new import_web32.PublicKey(voteAccountStr);
-    const bondAccount = await client.getValidatorBond(voteAccount);
+    const bondAccount = await client.getValidatorBond(bondType, bondName, voteAccount);
     if (!bondAccount) {
       throw new Error("Validator bond account not found");
     }
@@ -276,6 +293,8 @@ import_commander.program.command("set-withdraw-authority").description("Set or u
     }
     const newWithdrawAuthority = options.newAuthority ? new import_web32.PublicKey(options.newAuthority) : null;
     const tx = await client.setWithdrawAuthority({
+      bondType,
+      name: bondName,
       voteAccount,
       newWithdrawAuthority
     });
@@ -294,13 +313,17 @@ import_commander.program.command("set-withdraw-authority").description("Set or u
 import_commander.program.command("configure").description("Update program configuration (authority and/or reserve)").option("-a, --new-authority <pubkey>", "New authority address").option("-r, --new-reserve <pubkey>", "New reserve address").action(async (opts) => {
   const spinner = (0, import_ora.default)("Updating program configuration...").start();
   const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
   try {
     if (!opts.newAuthority && !opts.newReserve) {
       throw new Error("At least one of --new-authority or --new-reserve must be provided");
     }
     const newAuthority = opts.newAuthority ? new import_web32.PublicKey(opts.newAuthority) : void 0;
     const newReserve = opts.newReserve ? new import_web32.PublicKey(opts.newReserve) : void 0;
-    const tx = await client.configure({
+    const tx = await client.bondConfigure({
+      bondType,
+      name: bondName,
       newAuthority,
       newReserve
     });
@@ -317,6 +340,65 @@ import_commander.program.command("configure").description("Update program config
     process.exit(1);
   }
 });
+import_commander.program.command("get-bond-state").description("Get bond state information").action(async () => {
+  const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
+  try {
+    const state = await client.getBondState(bondType, bondName);
+    if (!state) {
+      console.log(import_chalk.default.yellow("Bond state not found"));
+      return;
+    }
+    console.log(import_chalk.default.cyan("====== Bond State: ======\n"));
+    console.log(import_chalk.default.white(JSON.stringify(state, null, 2)));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Failed to get bond state info: ${error}`));
+    process.exit(1);
+  }
+});
+import_commander.program.command("start-bond").description("Start bond command").requiredOption("-d, --duration <seconds>", "Bond session duration in seconds").action(async (opts) => {
+  const spinner = (0, import_ora.default)("Starting bond...").start();
+  const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
+  const duration = Number.parseInt(opts.duration, 10);
+  try {
+    const tx = await client.bondStart({ bondType, name: bondName, duration_secs: duration });
+    spinner.succeed(import_chalk.default.green(`Bond started successfully!`));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to start bond: ${error}`));
+    process.exit(1);
+  }
+});
+import_commander.program.command("finish-bond").description("Finish bond command").action(async () => {
+  const spinner = (0, import_ora.default)("Finishing bond...").start();
+  const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
+  try {
+    const tx = await client.bondFinish({ bondType, name: bondName });
+    spinner.succeed(import_chalk.default.green(`Bond finished successfully!`));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to finish bond: ${error}`));
+    process.exit(1);
+  }
+});
+import_commander.program.command("get-collateral-type").description("Get bond collateral type").action(async () => {
+  const { client } = useContext();
+  const bondType = parseBondType(import_commander.program.opts().bondType);
+  const bondName = import_commander.program.opts().bondName;
+  try {
+    const collateralType = await client.getBondCollateralType(bondType, bondName);
+    console.log(import_chalk.default.cyan("Collateral Type:"));
+    console.log(import_chalk.default.white(JSON.stringify(collateralType, null, 2)));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Failed to get collateral type: ${error}`));
+    process.exit(1);
+  }
+});
 import_commander.program.command("*", { isDefault: true, hidden: true }).allowExcessArguments(true).action(() => {
   import_commander.program.help();
 });
@@ -329,32 +411,37 @@ import_commander.program.parseAsync().catch((e) => {
   }
   process.exit();
 });
-function prettyJson(obj, omitKeys = ["bump"]) {
-  const convertValue = (value) => {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-      return value;
+function parseBondType(t) {
+  const x = (t || "").toLowerCase();
+  if (x === "crowdfunding") {
+    return { crowdfunding: {} };
+  }
+  if (x === "performance") {
+    return { performance: {} };
+  }
+  console.error(import_chalk.default.red(`Invalid bond type: ${t}`));
+  process.exit(1);
+}
+function parseCollateralType(input) {
+  if (input === "sol") {
+    return { native: {} };
+  } else if (input.startsWith("tokenMint:")) {
+    const parts = input.split(":");
+    if (parts.length !== 2) {
+      throw new Error("Invalid tokenMint format. Use tokenMint:<address>");
     }
-    if (value && typeof value === "object") {
-      if (typeof value.toString === "function" && value.constructor.name !== "Object") {
-        return value.toString();
-      }
-      if (Array.isArray(value)) {
-        return value.map((item) => convertValue(item));
-      }
-      const converted2 = {};
-      for (const [k, v] of Object.entries(value)) {
-        if (omitKeys.includes(k)) {
-          continue;
-        }
-        converted2[k] = convertValue(v);
-      }
-      return converted2;
+    return { token: [new import_web32.PublicKey(parts[1])] };
+  } else if (input.startsWith("stakeAccount:")) {
+    const parts = input.split(":");
+    if (parts.length !== 2) {
+      throw new Error("Invalid stakeAccount format. Use stakeAccount:<address>");
     }
-    return String(value);
-  };
-  const converted = convertValue(obj);
-  return JSON.stringify(converted, null, 2);
+    return { stakeAccount: {} };
+  } else {
+    throw new Error("Unsupported collateral type. Use sol, tokenMint:<address>, or stakeAccount:<address>");
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCollateralType
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpool/bond-cli",
-  "version": "1.2.0-next.0",
+  "version": "1.2.0-next.2",
   "description": "JBond CLI for interacting with the Solana program",
   "main": "./dist/cli.js",
   "bin": {