@jpool/bond-cli 1.1.0

package/README.md

@@ -0,0 +1,234 @@
+# JBond CLI
+
+A command-line interface for interacting with the JBond Solana program, which manages validator bond collateral.
+
+## Commands
+
+### Initialize Global State
+
+Initialize Bond Global State and set reserve address.
+
+```bash
+pnpm jbond initialize -k <KEYPAIR_PATH> -r <RESERVE_ADDRESS>
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -r, --reserve <RESERVE_ADDRESS> Reserve address
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond initialize -r 61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz -c mainnet-beta
+```
+
+**Note**: This command should only be run once by the program authority.
+
+### Register Validator
+
+Register a new validator and deposit initial collateral.
+
+```bash
+pnpm jbond register-validator <vote-account> <amount> -k <path>
+
+Arguments:
+  vote-account          Vote account public key
+  amount               Initial collateral amount in SOL
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -w, Optional withdraw authority
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond register-validator 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 1.1 -k ~/.config/solana/id.json -c mainnet-beta
+```
+
+**Requirements**:
+
+- Minimum collateral amount is determined by the program (typically 1 SOL)
+- The keypair must have sufficient SOL for collateral + transaction fees
+
+### Top Up Collateral
+
+Add additional collateral to an existing validator bond.
+
+```bash
+pnpm jbond topup-collateral <vote-account> <amount> -k <path>
+
+Arguments:
+  vote-account          Vote account public key
+  amount               Amount to add in SOL
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond topup-collateral 686JcEJ98r8fMtUiVuKiz4WRoBpJ2Sm9zMhdc2b6H4bu 50 -c mainnet-beta
+```
+
+### Withdraw Collateral
+
+Withdraw collateral from validator bond account.
+
+```bash
+pnpm jbond withdraw-collateral <vote-account> <destination> <amount> [options]
+
+Arguments:
+  vote-account          Vote account public key
+  destination          Destination address for withdrawn funds
+  amount               Amount to withdraw in SOL
+
+Options:
+  -k, --keypair <path>  Path to keypair file (default: ~/.config/solana/id.json)
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond withdraw-collateral 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
+
+### Claim Compensation
+
+Claim compensation from a validator's collateral to the reserve (authority only).
+
+```bash
+pnpm jbond claim-compensation <vote-account> <amount> -k <path>
+
+Arguments:
+  vote-account          Vote account public key
+  amount               Amount to claim in SOL
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond claim-compensation GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 10 -k <path> -c mainnet-beta
+```
+
+**Note**: Only the program authority can execute withdrawals.
+
+### Update Global Config
+
+```
+pnpm jbond configure [options]
+
+Options:
+-k, --keypair <KEYPAIR_PATH> Path to keypair file (default: ~/.config/solana/id.json)
+-a, --new-authority <PUBKEY> New authority public key
+-r, --new-reserve <PUBKEY> New reserve address
+-c, --cluster <CLUSTER_NAME> Solana cluster (devnet or mainnet-beta)
+
+Examples:
+
+pnpm jbond configure -a 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin -c mainnet-beta
+pnpm jbond configure -r 61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz -c mainnet-beta
+pnpm jbond configure \
+-a 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin\
+-r 61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz\
+-c mainnet-beta
+```
+
+### Validator Info
+
+Display information about a validator bond account.
+
+```bash
+pnpm jbond validator-info <vote-account> [options]
+
+Arguments:
+  vote-account          Vote account public key
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -v, --validator <pubkey> Validator public key,
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond validator-info GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD -k <path> -c mainnet-beta
+```
+
+**Displays**:
+
+- Validator identity
+- Vote account
+- Withdrawal authority
+- Active status
+- Creation timestamp
+
+### Global state Info
+
+Display information about the global state.
+
+```bash
+pnpm jbond state [options]
+
+Options:
+  -k, --keypair <KEYPAIR_PATH>  Path to keypair file (default: ~/.config/solana/id.json)
+  -c, --cluster <CLUSTER_NAME> Solana cluster(devnet or mainnet-beta)
+
+Example:
+  pnpm jbond state -k <path> -c mainnet-beta
+```
+
+**Displays**:
+
+- Authority public key
+- Total number of validators
+- Current epoch
+
+## Usage Examples
+
+### Complete Validator Registration Flow
+
+```bash
+# 1. Check current global state
+pnpm jbond global-state-info -c mainnet-beta
+
+# 2. Register as a validator with 100 SOL collateral
+pnpm jbond register-validator GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 100  -c mainnet-beta
+
+# 3. Verify registration
+pnpm jbond validator-info GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD -c mainnet-beta
+
+# 4. Top up with additional 50 SOL
+pnpm jbond topup-collateral GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 50 -c mainnet-beta
+```
+
+### Authority Operations
+
+```bash
+# As authority, withdraw compensation from underperforming validator
+pnpm jbond claim-compensation GHRvDXj9BfACkJ9CoLWbpi2UkMVti9DwXJGsaFT9XDcD 5 -c mainnet-beta
+
+# Check pool statistics
+pnpm jbond global-state-info -c mainnet-beta
+```
+
+## Error Handling
+
+Common errors and solutions:
+
+### `Failed to load keypair`
+
+- Ensure the keypair file exists at the specified path
+- Check file permissions
+- Verify the keypair file is in valid JSON format
+
+### `InsufficientCollateral`
+
+- The collateral amount is below the minimum requirement
+- Check the program's minimum collateral requirement
+
+### `Unauthorized`
+
+- Only the authority can withdraw compensations
+- Ensure you're using the correct authority keypair
+
+### `Account already in use`
+
+- The validator is already registered
+- Use `topup-collateral` to add more funds instead

package/dist/cli.js

@@ -0,0 +1,316 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_web32 = require("@solana/web3.js");
+var import_chalk = __toESM(require("chalk"));
+var import_commander = require("commander");
+var import_ora = __toESM(require("ora"));
+
+// src/context.ts
+var import_node_buffer = require("buffer");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_anchor = require("@coral-xyz/anchor");
+var import_bond_sdk = require("@jpool/bond-sdk");
+var import_web3 = require("@solana/web3.js");
+var DEFAULT_CLUSTER = "devnet";
+var context;
+function useContext() {
+  return context;
+}
+function initContext({ cluster, env, keypair }) {
+  const opts = import_anchor.AnchorProvider.defaultOptions();
+  const connection = new import_web3.Connection(resolveRpcUrl(cluster), opts.commitment);
+  const wallet = new import_anchor.Wallet(resolveKeypair(keypair));
+  const provider = new import_anchor.AnchorProvider(connection, wallet, opts);
+  const client = new import_bond_sdk.JBondClient(provider).env(env);
+  return context = { keypair: wallet.payer, provider, client, cluster: cluster ?? DEFAULT_CLUSTER };
+}
+function resolveRpcUrl(cluster) {
+  try {
+    if (!cluster) {
+      throw new Error("No cluster provided");
+    }
+    return (0, import_web3.clusterApiUrl)(cluster);
+  } catch {
+    if (cluster && cluster.startsWith("http")) {
+      return cluster;
+    }
+    return (0, import_web3.clusterApiUrl)(DEFAULT_CLUSTER);
+  }
+}
+function resolveKeypair(path) {
+  let buffer;
+  if (path) {
+    buffer = (0, import_node_fs.readFileSync)(path);
+  } else if ((0, import_node_fs.existsSync)("keypair.json")) {
+    buffer = (0, import_node_fs.readFileSync)("keypair.json");
+  } else if (process.env.CLI_SOLANA_KEYPAIR) {
+    buffer = (0, import_node_fs.readFileSync)(process.env.CLI_SOLANA_KEYPAIR);
+  } else {
+    buffer = (0, import_node_fs.readFileSync)(
+      (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "solana", "id.json").replace(/\\/g, "/")
+    );
+  }
+  return import_web3.Keypair.fromSecretKey(
+    import_node_buffer.Buffer.from(JSON.parse(buffer.toString()))
+  );
+}
+
+// package.json
+var version = "1.0.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) => {
+  const opts = command.opts();
+  const { provider, client } = initContext(opts);
+  console.log(import_chalk.default.dim(`# Version: ${command.version()}`));
+  console.log(import_chalk.default.dim(`# Program: ${client.programId}`));
+  console.log(import_chalk.default.dim(`# Keypair: ${provider.wallet.publicKey}`));
+  console.log(import_chalk.default.dim(`# Rpc Url: ${provider.connection.rpcEndpoint}`));
+  console.log("\n");
+}).hook("postAction", (_c) => {
+  process.exit();
+});
+import_commander.program.command("info").description("Get global state information").action(async () => {
+  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 Information:"));
+    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}`));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Failed to get global state info: ${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();
+  const { client } = useContext();
+  const reserve = new import_web32.PublicKey(opts.reserve);
+  const authority = opts.claimAuthority ? new import_web32.PublicKey(opts.claimAuthority) : void 0;
+  try {
+    const tx = await client.initialize({ reserve, authority });
+    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}`));
+  }
+});
+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();
+  try {
+    const voteAccount = new import_web32.PublicKey(voteAccountStr);
+    const initialCollateral = Number.parseFloat(amount);
+    if (Number.isNaN(initialCollateral) || initialCollateral <= 0) {
+      throw new Error("Invalid collateral amount");
+    }
+    const tx = await client.registerValidator({
+      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(`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) => {
+  const spinner = (0, import_ora.default)("Topping up collateral...").start();
+  const { client } = useContext();
+  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!`));
+    console.log(import_chalk.default.gray(`Signature: ${signature}`));
+    console.log(import_chalk.default.gray(`Top-up amount: ${topUpAmount} SOL`));
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to top up collateral: ${error}`));
+    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) => {
+  const spinner = (0, import_ora.default)("Withdrawing collateral...").start();
+  const { client } = useContext();
+  try {
+    const voteAccount = new import_web32.PublicKey(voteAccountStr);
+    const destination = new import_web32.PublicKey(destinationStr);
+    const withdrawAmount = Number.parseFloat(amount);
+    if (Number.isNaN(withdrawAmount) || withdrawAmount <= 0) {
+      throw new Error("Invalid withdrawal amount");
+    }
+    const bondAccount = await client.getValidatorBond(voteAccount);
+    if (!bondAccount) {
+      throw new Error("Validator bond account not found");
+    }
+    const tx = await client.withdrawCollateral({ voteAccount, destination, 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`));
+    console.log(import_chalk.default.gray(`Destination: ${destinationStr}`));
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to withdraw collateral: ${error}`));
+    process.exit(1);
+  }
+});
+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();
+  try {
+    const voteAccount = new import_web32.PublicKey(voteAccountStr);
+    const withdrawAmount = Number.parseFloat(amount);
+    if (Number.isNaN(withdrawAmount) || withdrawAmount <= 0) {
+      throw new Error("Invalid withdrawal amount");
+    }
+    const tx = await client.claimCompensation({
+      voteAccount,
+      amount: withdrawAmount
+    });
+    spinner.succeed(import_chalk.default.green(`Compensation withdrawn successfully!`));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+    console.log(import_chalk.default.gray(`Amount: ${withdrawAmount} SOL`));
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to withdraw compensation: ${error}`));
+    process.exit(1);
+  }
+});
+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();
+  try {
+    const voteAccount = new import_web32.PublicKey(voteAccountStr);
+    const [validatorBondAddress] = client.pda.validatorBond(voteAccount);
+    console.log(import_chalk.default.gray(`Validator Bond Address: ${validatorBondAddress.toString()}`));
+    const state = await client.getValidatorBond(
+      voteAccount
+    );
+    if (!state) {
+      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}`));
+    } 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")}`
+      )
+    );
+    console.log(import_chalk.default.white(`  Created At: ${state.createdAt}`));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Failed to get validator info: ${error}`));
+    process.exit(1);
+  }
+});
+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();
+  try {
+    const voteAccount = new import_web32.PublicKey(voteAccountStr);
+    const bondAccount = await client.getValidatorBond(voteAccount);
+    if (!bondAccount) {
+      throw new Error("Validator bond account not found");
+    }
+    if (!bondAccount.identity.equals(keypair.publicKey)) {
+      throw new Error("Signer must be the validator identity");
+    }
+    const newWithdrawAuthority = options.newAuthority ? new import_web32.PublicKey(options.newAuthority) : null;
+    const tx = await client.setWithdrawAuthority({
+      voteAccount,
+      newWithdrawAuthority
+    });
+    spinner.succeed(import_chalk.default.green(`Withdrawal authority updated successfully!`));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+    if (newWithdrawAuthority) {
+      console.log(import_chalk.default.gray(`New withdrawal authority: ${newWithdrawAuthority.toString()}`));
+    } else {
+      console.log(import_chalk.default.gray(`Withdrawal authority removed (identity only)`));
+    }
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to set withdrawal authority: ${error}`));
+    process.exit(1);
+  }
+});
+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();
+  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({
+      newAuthority,
+      newReserve
+    });
+    spinner.succeed(import_chalk.default.green(`Program configuration updated successfully!`));
+    console.log(import_chalk.default.gray(`Transaction: ${tx}`));
+    if (newAuthority) {
+      console.log(import_chalk.default.gray(`New authority: ${newAuthority.toString()}`));
+    }
+    if (newReserve) {
+      console.log(import_chalk.default.gray(`New reserve: ${newReserve.toString()}`));
+    }
+  } catch (error) {
+    spinner.fail(import_chalk.default.red(`Failed to update configuration: ${error}`));
+    process.exit(1);
+  }
+});
+import_commander.program.command("*", { isDefault: true, hidden: true }).allowExcessArguments(true).action(() => {
+  import_commander.program.help();
+});
+import_commander.program.parseAsync().catch((e) => {
+  console.log(import_chalk.default.red(e.message));
+  if (e.logs) {
+    console.log(
+      import_chalk.default.red(JSON.stringify(e.logs, null, 2))
+    );
+  }
+  process.exit();
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jpool/bond-cli",
+  "version": "1.1.0",
+  "description": "JBond CLI for interacting with the Solana program",
+  "main": "./dist/cli.js",
+  "bin": {
+    "jbond": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "release": "release-it",
+    "release:ci": "release-it --ci -VV",
+    "release:dry": "release-it --ci --dry-run",
+    "release:pre": "release-it --preRelease=next -VV",
+    "release:pre:dry": "release-it --preRelease=next --dry-run --ci",
+    "postinstall": "npm run build"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@jpool/bond-sdk": "workspace:",
+    "@solana/web3.js": "^1.98.4",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1",
+    "dotenv": "^17.2.3",
+    "ora": "^9.0.0"
+  },
+  "devDependencies": {
+    "release-it-config": "workspace:",
+    "tsup": "^8.5.0"
+  }
+}