@argonprotocol/mainchain 1.1.0 → 1.2.0

package/lib/chunk-BQR6FEVP.js

@@ -0,0 +1,854 @@
+import {
+  Accountset,
+  BidPool,
+  BitcoinLocks,
+  CohortBidder,
+  Keyring,
+  MICROGONS_PER_ARGON,
+  MiningBids,
+  TxSubmitter,
+  Vault,
+  VaultMonitor,
+  createKeyringPair,
+  formatArgons,
+  getClient,
+  keyringFromSuri,
+  mnemonicGenerate,
+  parseSubaccountRange
+} from "./chunk-RXCQYVE7.js";
+
+// src/clis/index.ts
+import { Command as Command6, Option } from "@commander-js/extra-typings";
+
+// src/clis/accountCli.ts
+import { Command } from "@commander-js/extra-typings";
+import { printTable } from "console-table-printer";
+import { cryptoWaitReady } from "@polkadot/util-crypto";
+import { writeFileSync } from "node:fs";
+import * as process2 from "node:process";
+function accountCli() {
+  const program = new Command("accounts").description(
+    "Manage subaccounts from a single keypair"
+  );
+  program.command("watch").description("Watch for blocks closed by subaccounts").action(async () => {
+    const accountset = await accountsetFromCli(program);
+    const accountMiners = await accountset.watchBlocks();
+    accountMiners.events.on("mined", (_block, mined) => {
+      console.log("Your accounts authored a block", mined);
+    });
+    accountMiners.events.on("minted", (_block, minted) => {
+      console.log("Your accounts minted argons", minted);
+    });
+  });
+  program.command("list", { isDefault: true }).description("Show subaccounts").option("--addresses", "Just show a list of ids").action(async ({ addresses }) => {
+    const { subaccounts } = globalOptions(program);
+    const accountset = await accountsetFromCli(program);
+    if (addresses) {
+      const addresses2 = accountset.addresses;
+      console.log(addresses2.join(","));
+      process2.exit(0);
+    }
+    const [argonots, argons, seats, bids] = await Promise.all([
+      accountset.totalArgonotsAt(),
+      accountset.totalArgonsAt(),
+      accountset.miningSeats(),
+      accountset.bids()
+    ]);
+    const accountSubset = subaccounts ? accountset.getAccountsInRange(subaccounts) : void 0;
+    const status = accountset.status({
+      argons,
+      argonots,
+      accountSubset,
+      seats,
+      bids
+    });
+    printTable(status);
+    process2.exit(0);
+  });
+  program.command("create").description('Create an account "env" file and optionally register keys').requiredOption(
+    "--path <path>",
+    "The path to an env file to create (convention is .env.<name>)"
+  ).option(
+    "--register-keys-to <url>",
+    "Register the keys to a url (normally this is localhost)"
+  ).action(async ({ registerKeysTo, path }) => {
+    const { accountPassphrase, accountSuri, accountFilePath } = globalOptions(program);
+    const accountset = await accountsetFromCli(program);
+    process2.env.KEYS_MNEMONIC ||= mnemonicGenerate();
+    if (registerKeysTo) {
+      await accountset.registerKeys(registerKeysTo);
+      console.log("Keys registered to", registerKeysTo);
+    }
+    const envData = {
+      ACCOUNT_JSON_PATH: accountFilePath,
+      ACCOUNT_SURI: accountSuri,
+      ACCOUNT_PASSPHRASE: accountPassphrase,
+      KEYS_MNEMONIC: process2.env.KEYS_MNEMONIC,
+      SUBACCOUNT_RANGE: "0-49"
+    };
+    let envfile = "";
+    for (const [key, value] of Object.entries(envData)) {
+      if (key) {
+        const line = `${key}=${String(value)}`;
+        envfile += line + "\n";
+      }
+    }
+    writeFileSync(path, envfile);
+    console.log("Created env file at", path);
+    process2.exit();
+  });
+  program.command("new-key-seed").description("Create a new mnemonic for runtime keys").action(async () => {
+    await cryptoWaitReady();
+    const mnemonic = mnemonicGenerate();
+    console.log(
+      "New mnemonic (add this to your .env as KEYS_MNEMONIC):",
+      mnemonic
+    );
+    process2.exit(0);
+  });
+  program.command("register-keys").description("Create an insert-keys script with curl").argument(
+    "[node-rpc-url]",
+    "The url to your node host (should be installed on machine via localhost)",
+    "http://localhost:9944"
+  ).option(
+    "--print-only",
+    "Output as curl commands instead of direct registration"
+  ).action(async (nodeRpcUrl, { printOnly }) => {
+    const accountset = await accountsetFromCli(program);
+    if (printOnly) {
+      const { gran, seal } = accountset.keys();
+      const commands = [];
+      const data = [
+        {
+          jsonrpc: "2.0",
+          id: 0,
+          method: "author_insertKey",
+          params: ["gran", gran.privateKey, gran.publicKey]
+        },
+        {
+          jsonrpc: "2.0",
+          id: 1,
+          method: "author_insertKey",
+          params: ["seal", seal.privateKey, seal.publicKey]
+        }
+      ];
+      for (const key of data) {
+        commands.push(
+          `curl -X POST -H "Content-Type: application/json" -d '${JSON.stringify(key)}' ${nodeRpcUrl}`
+        );
+      }
+      console.log(commands.join(" && "));
+    } else {
+      await accountset.registerKeys(nodeRpcUrl);
+    }
+    process2.exit();
+  });
+  program.command("consolidate").description("Consolidate all argons into parent account").option(
+    "-s, --subaccounts <range>",
+    "Restrict this operation to a subset of the subaccounts (eg, 0-10)",
+    parseSubaccountRange
+  ).action(async ({ subaccounts }) => {
+    const accountset = await accountsetFromCli(program);
+    const result = await accountset.consolidate(subaccounts);
+    printTable(result);
+    process2.exit(0);
+  });
+  return program;
+}
+
+// src/clis/index.ts
+import { configDotenv } from "dotenv";
+import Path from "node:path";
+
+// src/clis/vaultCli.ts
+import { Command as Command2 } from "@commander-js/extra-typings";
+function vaultCli() {
+  const program = new Command2("vaults").description(
+    "Monitor vaults and manage securitization"
+  );
+  program.command("list", { isDefault: true }).description("Show current state of vaults").action(async () => {
+    const accountset = await accountsetFromCli(program);
+    const vaults = new VaultMonitor(accountset, void 0, {
+      vaultOnlyWatchMode: true
+    });
+    await vaults.monitor(true);
+    process.exit(0);
+  });
+  program.command("modify-securitization").description("Change the vault securitization ratio").requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption(
+    "-a, --argons <amount>",
+    "The number of argons to set as securitization",
+    parseFloat
+  ).option("--ratio <ratio>", "The new securitization ratio", parseFloat).option(
+    "--tip <amount>",
+    "The tip to include with the transaction",
+    parseFloat
+  ).action(async ({ tip, argons, vaultId, ratio }) => {
+    const accountset = await accountsetFromCli(program);
+    const client = await accountset.client;
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
+    const rawVault = (await client.query.vaults.vaultsById(vaultId)).unwrap();
+    if (rawVault.operatorAccountId.toHuman() !== accountset.seedAddress) {
+      console.error("Vault does not belong to this account");
+      process.exit(1);
+    }
+    const existingFunds = rawVault.securitization.toBigInt();
+    const additionalFunds = microgons > existingFunds ? microgons - existingFunds : 0n;
+    const tx = client.tx.vaults.modifyFunding(
+      vaultId,
+      microgons,
+      ratio !== void 0 ? BigNumber(ratio).times(BigNumber(2).pow(64)).toFixed(0) : rawVault.securitizationRatio.toBigInt()
+    );
+    const submit = new TxSubmitter(client, tx, accountset.txSubmitterPair);
+    const canAfford = await submit.canAfford({
+      tip: resolvedTip,
+      unavailableBalance: additionalFunds
+    });
+    if (!canAfford.canAfford) {
+      console.warn("Insufficient balance to modify vault securitization", {
+        ...canAfford,
+        addedSecuritization: additionalFunds
+      });
+      process.exit(1);
+    }
+    try {
+      const result = await submit.submit({ tip: resolvedTip });
+      await result.inBlockPromise;
+      console.log("Vault securitization modified");
+      process.exit();
+    } catch (error) {
+      console.error("Error modifying vault securitization", error);
+      process.exit(1);
+    }
+  });
+  program.command("make-bitcoin-space").description(
+    "Make bitcoin space in a vault and lock it immediately in the same tx."
+  ).requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption(
+    "-a, --argons <amount>",
+    "The number of argons to add",
+    parseFloat
+  ).requiredOption(
+    "--bitcoin-pubkey <pubkey>",
+    "The pubkey to use for the bitcoin lock"
+  ).option(
+    "--tip <amount>",
+    "The tip to include with the transaction",
+    parseFloat
+  ).action(async ({ tip, argons, vaultId, bitcoinPubkey }) => {
+    let pubkey = bitcoinPubkey;
+    if (!bitcoinPubkey.startsWith("0x")) {
+      pubkey = `0x${bitcoinPubkey}`;
+    }
+    if (pubkey.length !== 68) {
+      throw new Error(
+        "Bitcoin pubkey must be 66 characters (add 0x in front optionally)"
+      );
+    }
+    const accountset = await accountsetFromCli(program);
+    const client = await accountset.client;
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
+    const bitcoinLocks = new BitcoinLocks(Promise.resolve(client));
+    const existentialDeposit = client.consts.balances.existentialDeposit.toBigInt();
+    const tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
+    const rawVault = (await client.query.vaults.vaultsById(vaultId)).unwrap();
+    if (rawVault.operatorAccountId.toHuman() !== accountset.seedAddress) {
+      console.error("Vault does not belong to this account");
+      process.exit(1);
+    }
+    const vaultModifyTx = client.tx.vaults.modifyFunding(
+      vaultId,
+      microgons,
+      rawVault.securitizationRatio.toBigInt()
+    );
+    const vaultTxFee = (await vaultModifyTx.paymentInfo(accountset.txSubmitterPair)).partialFee.toBigInt();
+    const vault = new Vault(vaultId, rawVault, tickDuration);
+    const argonsNeeded = microgons - vault.securitization;
+    const argonsAvailable = microgons - vault.availableBitcoinSpace();
+    const account = await client.query.system.account(accountset.seedAddress);
+    const freeBalance = account.data.free.toBigInt();
+    const {
+      tx: lockTx,
+      btcFee,
+      txFee
+    } = await bitcoinLocks.buildBitcoinLockTx({
+      vaultId,
+      keypair: accountset.txSubmitterPair,
+      amount: argonsAvailable,
+      bitcoinXpub: pubkey,
+      tip: resolvedTip,
+      reducedBalanceBy: argonsNeeded + vaultTxFee + resolvedTip
+    });
+    if (argonsNeeded + txFee + vaultTxFee + resolvedTip + btcFee + existentialDeposit > freeBalance) {
+      console.warn(
+        "Insufficient balance to add bitcoin space and use bitcoins",
+        {
+          freeBalance,
+          txFee,
+          vaultTxFee,
+          btcFee,
+          argonsAvailable,
+          vaultMicrogons: microgons,
+          existentialDeposit,
+          neededBalanceAboveED: argonsNeeded + txFee + resolvedTip + btcFee + vaultTxFee
+        }
+      );
+      process.exit(1);
+    }
+    console.log("Adding bitcoin space and locking bitcoins...", {
+      newArgonsAvailable: argonsAvailable,
+      txFee,
+      vaultTxFee,
+      btcFee,
+      resolvedTip
+    });
+    const txSubmitter = new TxSubmitter(
+      client,
+      client.tx.utility.batchAll([vaultModifyTx, lockTx]),
+      accountset.txSubmitterPair
+    );
+    const result = await txSubmitter.submit({ tip: resolvedTip });
+    try {
+      await result.inBlockPromise;
+      console.log("Bitcoin space done");
+    } catch (error) {
+      console.error("Error using bitcoin space", error);
+      process.exit(1);
+    }
+  });
+  return program;
+}
+
+// src/clis/miningCli.ts
+import { Command as Command3 } from "@commander-js/extra-typings";
+import { printTable as printTable2 } from "console-table-printer";
+function miningCli() {
+  const program = new Command3("mining").description(
+    "Watch mining seats or setup bidding"
+  );
+  program.command("list", { isDefault: true }).description("Monitor all miners").action(async () => {
+    const accountset = await accountsetFromCli(program);
+    const bids = new MiningBids(accountset.client);
+    const api = await accountset.client;
+    let lastMiners = {};
+    function print(blockNumber) {
+      console.clear();
+      const toPrint = Object.entries(lastMiners).map(([seat, miner]) => ({
+        seat,
+        ...miner
+      }));
+      if (!toPrint.length) {
+        console.log("No active miners");
+      } else {
+        console.log(`Miners at block ${blockNumber}`);
+        printTable2(
+          toPrint.map((x) => ({
+            ...x,
+            bid: x.bid ? formatArgons(x.bid) : "-",
+            isLastDay: x.isLastDay ? "Y" : "",
+            miner: x.miner
+          }))
+        );
+      }
+      if (!bids.nextCohort.length) {
+        console.log(
+          "-------------------------------------\nNo bids for next cohort"
+        );
+      } else {
+        bids.print();
+      }
+    }
+    const { unsubscribe } = await bids.watch(
+      accountset.namedAccounts,
+      void 0,
+      print
+    );
+    console.log("Watching miners...");
+    const minMiners = api.consts.miningSlot.minCohortSize.toNumber();
+    const unsub = await api.query.miningSlot.nextFrameId(
+      async (nextFrameId) => {
+        const frames = new Array(nextFrameId.toNumber()).fill(0).map((_, i) => nextFrameId.toNumber() - i).sort();
+        const unseenFrames = new Set(frames);
+        const entries = await api.query.miningSlot.minersByCohort.entries();
+        const block = await api.query.system.number();
+        const sortedEntries = entries.sort((a, b) => {
+          const aIndex = a[0].args[0].toNumber();
+          const bIndex = b[0].args[0].toNumber();
+          return aIndex - bIndex;
+        });
+        for (const [rawFrameId, miners] of sortedEntries) {
+          const frameId = rawFrameId.args[0].toNumber();
+          unseenFrames.delete(frameId);
+          let i = 0;
+          for (const miner of miners) {
+            const address = miner.accountId.toHuman();
+            const startingFrameId = miner.startingFrameId.toNumber();
+            lastMiners[`${frameId}-${i}`] = {
+              miner: accountset.namedAccounts.get(address) ?? address,
+              bid: miner.bid.toBigInt(),
+              isLastDay: nextFrameId.toNumber() - startingFrameId === 10
+            };
+            i++;
+          }
+          while (i < minMiners) {
+            lastMiners[`${frameId}-${i}`] = {
+              miner: "none"
+            };
+            i++;
+          }
+        }
+        for (const frameId of unseenFrames) {
+          for (let i = 0; i < minMiners; i++) {
+            lastMiners[`${frameId}-${i}`] = {
+              miner: "none"
+            };
+          }
+        }
+        print(block.toNumber());
+      }
+    );
+    process.on("SIGINT", () => {
+      unsubscribe();
+      unsub();
+      process.exit(0);
+    });
+  });
+  program.command("bid").description("Submit mining bids within a range of parameters").option("--min-bid <amount>", "The minimum bid amount to use", parseFloat).option("--max-bid <amount>", "The maximum bid amount to use", parseFloat).option(
+    "--max-seats <n>",
+    "The maximum number of seats to bid on for the slot",
+    parseInt
+  ).option(
+    "--max-balance <argons>",
+    "Use a maximum amount of the user's balance for the slot. If this ends in a percent, it will be a percent of the funds"
+  ).option("--bid-increment <argons>", "The bid increment", parseFloat, 0.01).option("--bid-delay <ticks>", "Delay between bids in ticks", parseInt, 0).option("--run-continuous", "Keep running and rebid every day").option(
+    "--proxy-for-address <address>",
+    "The seed account to proxy for (eg: 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty)"
+  ).action(
+    async ({
+      maxSeats,
+      runContinuous,
+      maxBid,
+      minBid,
+      maxBalance,
+      bidDelay,
+      bidIncrement,
+      proxyForAddress
+    }) => {
+      const accountset = await accountsetFromCli(program, proxyForAddress);
+      let cohortBidder;
+      const miningBids = new MiningBids(accountset.client, false);
+      const maxCohortSize = await miningBids.maxCohortSize();
+      const stopBidder = async (unsubscribe2) => {
+        if (cohortBidder) {
+          const stats = await cohortBidder.stop();
+          console.log("Final bidding result", {
+            cohortStartingFrameId: cohortBidder.cohortStartingFrameId,
+            ...stats
+          });
+          cohortBidder = void 0;
+          if (!runContinuous) {
+            unsubscribe2();
+            process.exit();
+          }
+        }
+      };
+      const { unsubscribe } = await miningBids.onCohortChange({
+        async onBiddingEnd(cohortStartingFrameId) {
+          if (cohortBidder?.cohortStartingFrameId === cohortStartingFrameId) {
+            await stopBidder(unsubscribe);
+          }
+        },
+        async onBiddingStart(cohortStartingFrameId) {
+          const seatsToWin = maxSeats ?? maxCohortSize;
+          const balance = await accountset.balance();
+          const feeWiggleRoom = BigInt(25e3);
+          const amountAvailable = balance - feeWiggleRoom;
+          let maxBidAmount = maxBid ? BigInt(maxBid * MICROGONS_PER_ARGON) : void 0;
+          let maxBalanceToUse = amountAvailable;
+          if (maxBalance !== void 0) {
+            if (maxBalance.endsWith("%")) {
+              let maxBalancePercent = parseInt(maxBalance);
+              let amountToBid = amountAvailable * BigInt(maxBalancePercent) / 100n;
+              if (amountToBid > balance) {
+                amountToBid = balance;
+              }
+              maxBalanceToUse = amountToBid;
+            } else {
+              maxBalanceToUse = BigInt(
+                Math.floor(parseFloat(maxBalance) * MICROGONS_PER_ARGON)
+              );
+            }
+            maxBidAmount ??= maxBalanceToUse / BigInt(seatsToWin);
+          }
+          if (maxBalanceToUse > amountAvailable) {
+            maxBalanceToUse = amountAvailable;
+          }
+          if (!maxBidAmount) {
+            console.error("No max bid amount set");
+            process.exit(1);
+          }
+          const subaccountRange = await accountset.getAvailableMinerAccounts(seatsToWin);
+          if (cohortBidder && cohortBidder?.cohortStartingFrameId !== cohortStartingFrameId) {
+            await stopBidder(unsubscribe);
+          }
+          cohortBidder = new CohortBidder(
+            accountset,
+            cohortStartingFrameId,
+            subaccountRange,
+            {
+              maxBid: maxBidAmount,
+              minBid: BigInt((minBid ?? 0) * MICROGONS_PER_ARGON),
+              bidIncrement: BigInt(
+                Math.floor(bidIncrement * MICROGONS_PER_ARGON)
+              ),
+              maxBudget: maxBalanceToUse,
+              bidDelay
+            }
+          );
+          await cohortBidder.start();
+        }
+      });
+    }
+  );
+  program.command("create-bid-proxy").description("Create a mining-bid proxy account for your main account").requiredOption(
+    "--outfile <path>",
+    "The file to use to store the proxy account json (eg: proxy.json)"
+  ).requiredOption(
+    "--fee-argons <argons>",
+    "How many argons should be sent to the proxy account for fees (proxies must pay fees)",
+    parseFloat
+  ).option(
+    "--proxy-passphrase <passphrase>",
+    "The passphrase for your proxy account"
+  ).action(async ({ outfile, proxyPassphrase, feeArgons }) => {
+    const { mainchainUrl } = globalOptions(program);
+    const client = await getClient(mainchainUrl);
+    const keyringPair = await saveKeyringPair({
+      filePath: outfile,
+      passphrase: proxyPassphrase
+    });
+    const address = keyringPair.address;
+    console.log(
+      `\u2705 Created proxy account at "${outfile}" with address ${address}`
+    );
+    const tx = client.tx.utility.batchAll([
+      client.tx.proxy.addProxy(address, "MiningBid", 0),
+      client.tx.balances.transferAllowDeath(
+        address,
+        BigInt(feeArgons * MICROGONS_PER_ARGON)
+      )
+    ]);
+    let keypair;
+    try {
+      const accountset = await accountsetFromCli(program);
+      keypair = accountset.txSubmitterPair;
+    } catch (e) {
+      const polkadotLink = `https://polkadot.js.org/apps/?rpc=${mainchainUrl}#/extrinsics/decode/${tx.toHex()}`;
+      console.log(`Complete the registration at this link:`, polkadotLink);
+      process.exit(0);
+    }
+    try {
+      await new TxSubmitter(client, tx, keypair).submit({
+        waitForBlock: true
+      });
+      console.log("Mining bid proxy added and funded.");
+      process.exit();
+    } catch (error) {
+      console.error("Error adding mining proxy", error);
+      process.exit(1);
+    }
+  });
+  return program;
+}
+
+// src/clis/liquidityCli.ts
+import { Command as Command4 } from "@commander-js/extra-typings";
+function liquidityCli() {
+  const program = new Command4("liquidity-pools").description(
+    "Monitor or bond to liquidity pools"
+  );
+  program.command("list", { isDefault: true }).description("Show or watch the vault bid pool rewards").action(async () => {
+    const accountset = await accountsetFromCli(program);
+    const bidPool = new BidPool(
+      accountset.client,
+      accountset.txSubmitterPair
+    );
+    await bidPool.watch();
+  });
+  program.command("bond").description("Bond argons to a liquidity pool").requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption(
+    "-a, --argons <amount>",
+    "The number of argons to set the vault to",
+    parseFloat
+  ).option(
+    "--tip <amount>",
+    "The tip to include with the transaction",
+    parseFloat
+  ).action(async ({ tip, argons, vaultId }) => {
+    const accountset = await accountsetFromCli(program);
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
+    const bidPool = new BidPool(
+      accountset.client,
+      accountset.txSubmitterPair
+    );
+    await bidPool.bondArgons(vaultId, microgons, { tip: resolvedTip });
+    console.log("Bonded argons to liquidity pool bond");
+    process.exit();
+  });
+  program.command("wait-for-space").description(
+    "Add bonded argons to a liquidity pool when the market rate is favorable"
+  ).requiredOption(
+    "--max-argons <amount>",
+    "Max daily argons to use per slot",
+    parseFloat
+  ).option(
+    "--min-pct-sharing <percent>",
+    "The minimum profit sharing percent to allow",
+    parseInt,
+    30
+  ).option(
+    "--tip <amount>",
+    "The tip to include with the transaction",
+    parseFloat
+  ).action(async ({ maxArgons, minPctSharing, tip }) => {
+    const maxAmountPerSlot = BigInt(maxArgons * MICROGONS_PER_ARGON);
+    const accountset = await accountsetFromCli(program);
+    const vaults = new VaultMonitor(
+      accountset,
+      {
+        liquidityPoolSpaceAvailable: 1000000n
+      },
+      { shouldLog: false }
+    );
+    const bidPool = new BidPool(
+      accountset.client,
+      accountset.txSubmitterPair
+    );
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    console.log("Waiting for liquidity pool space...");
+    vaults.events.on(
+      "liquidity-pool-space-above",
+      async (vaultId, amount) => {
+        const vault = vaults.vaultsById[vaultId];
+        if (vault.terms.liquidityPoolProfitSharing.times(100).toNumber() < minPctSharing) {
+          console.info(
+            `Skipping vault ${vaultId} due to lower profit sharing than ${minPctSharing}%`
+          );
+          return;
+        }
+        let amountToAdd = amount;
+        if (amountToAdd > maxAmountPerSlot) {
+          amountToAdd = maxAmountPerSlot;
+        }
+        await bidPool.bondArgons(vaultId, amountToAdd, { tip: resolvedTip });
+        console.log("Bonding argons to vault liquidity pool", {
+          vaultId,
+          amount: formatArgons(amountToAdd)
+        });
+      }
+    );
+    await vaults.monitor();
+  });
+  return program;
+}
+
+// src/clis/bitcoinCli.ts
+import { Command as Command5 } from "@commander-js/extra-typings";
+function bitcoinCli() {
+  const program = new Command5("bitcoin").description("Wait for bitcoin space");
+  program.command("watch").requiredOption(
+    "-a, --argons <argons>",
+    "Alert when bitcoin space exceeds this amount",
+    parseFloat
+  ).description("Watch for bitcoin space available").action(async ({ argons }) => {
+    const accountset = await accountsetFromCli(program);
+    const bot = new VaultMonitor(accountset, {
+      bitcoinSpaceAvailable: argons ? BigInt(argons * MICROGONS_PER_ARGON) : 1n
+    });
+    bot.events.on("bitcoin-space-above", async (vaultId, amount) => {
+      const vault = bot.vaultsById[vaultId];
+      const fee = vault.calculateBitcoinFee(amount);
+      const ratio = 100n * fee / amount;
+      console.log(
+        `Vault ${vaultId} has ${formatArgons(amount)} argons available for bitcoin. Fee ratio is ${ratio}%`
+      );
+    });
+    await bot.monitor();
+  });
+  program.command("wait-for-space").description("Lock bitcoin when available at a given rate").requiredOption(
+    "-a, --argons <amount>",
+    "Bitcoin argons needed. NOTE: your account must have enough to cover fees + tip after this amount.",
+    parseFloat
+  ).requiredOption(
+    "--bitcoin-xpub <xpub>",
+    "The xpub key to use for bitcoin locking"
+  ).option(
+    "--max-lock-fee <argons>",
+    "The max lock fee you're willing to pay",
+    parseFloat
+  ).option(
+    "--tip <amount>",
+    "The tip to include with the transaction",
+    parseFloat,
+    0
+  ).action(async ({ argons, bitcoinXpub, maxLockFee, tip }) => {
+    const amountToLock = BigInt(argons * MICROGONS_PER_ARGON);
+    const accountset = await accountsetFromCli(program);
+    await BitcoinLocks.waitForSpace(accountset, {
+      argonAmount: amountToLock,
+      bitcoinXpub,
+      maxLockFee: maxLockFee !== void 0 ? BigInt(maxLockFee * MICROGONS_PER_ARGON) : void 0,
+      tip: BigInt(tip * MICROGONS_PER_ARGON)
+    }).then(({ vaultId, satoshis, txFee, btcFee }) => {
+      console.log(
+        `Locked ${satoshis} satoshis in vault ${vaultId}. Tx fee=${formatArgons(
+          txFee
+        )}, Lock fee=${formatArgons(btcFee)}.`
+      );
+      process.exit(0);
+    });
+  });
+  return program;
+}
+
+// src/clis/keyringStore.ts
+import { promises } from "node:fs";
+import * as os from "node:os";
+var { readFile, writeFile } = promises;
+async function keyringFromFile(opts) {
+  if (!opts.filePath) {
+    throw new Error(
+      "No ACCOUNT account loaded (either ACCOUNT_SURI or ACCOUNT_JSON_PATH required)"
+    );
+  }
+  const path = opts.filePath.replace("~", os.homedir());
+  const json = JSON.parse(await readFile(path, "utf-8"));
+  let passphrase = opts.passphrase;
+  if (opts.passphraseFile) {
+    const passphrasePath = opts.passphraseFile.replace("~", os.homedir());
+    passphrase = await readFile(passphrasePath, "utf-8");
+  }
+  const mainAccount = new Keyring().createFromJson(json);
+  mainAccount.decodePkcs8(passphrase);
+  return mainAccount;
+}
+async function saveKeyringPair(opts) {
+  const { filePath, passphrase, cryptoType } = opts;
+  const keyring = createKeyringPair({ cryptoType });
+  if (filePath) {
+    const json = keyring.toJson(passphrase);
+    await writeFile(filePath, JSON.stringify(json, null, 2));
+  }
+  return keyring;
+}
+
+// src/clis/index.ts
+function globalOptions(program) {
+  return program.optsWithGlobals();
+}
+function buildCli() {
+  return new Command6("Argon CLI").option("-e, --env <path>", "The path to the account .env file to load").addOption(
+    new Option("-u, --mainchain-url <url>", "The mainchain URL to connect to").default("wss://rpc.argon.network").env("MAINCHAIN_URL")
+  ).addOption(
+    new Option(
+      "--account-file-path <jsonPath>",
+      "The path to your json seed file from polkadotjs"
+    ).env("ACCOUNT_JSON_PATH")
+  ).addOption(
+    new Option(
+      "--account-suri <secretUri>",
+      "A secret uri (suri) to use for the account"
+    ).env("ACCOUNT_SURI")
+  ).addOption(
+    new Option(
+      "--account-passphrase <password>",
+      "The password for your seed file"
+    ).env("ACCOUNT_PASSPHRASE")
+  ).addOption(
+    new Option(
+      "--account-passphrase-file <path>",
+      "The path to a password for your seed file"
+    )
+  ).addOption(
+    new Option(
+      "-s, --subaccounts <range>",
+      "Restrict this operation to a subset of the subaccounts (eg, 0-10)"
+    ).env("SUBACCOUNT_RANGE").argParser(parseSubaccountRange)
+  ).addCommand(accountCli()).addCommand(vaultCli()).addCommand(miningCli()).addCommand(liquidityCli()).addCommand(bitcoinCli());
+}
+async function accountsetFromCli(program, proxyForAddress) {
+  const opts = program.parent?.optsWithGlobals();
+  let keypair;
+  if (opts.accountSuri) {
+    keypair = keyringFromSuri(opts.accountSuri);
+  }
+  if (opts.accountFilePath) {
+    keypair = await keyringFromFile({
+      filePath: opts.accountFilePath,
+      passphrase: opts.accountPassphrase,
+      passphraseFile: opts.accountPassphraseFile
+    });
+  }
+  if (!keypair) {
+    throw new Error(
+      "No ACCOUNT account loaded (either ACCOUNT_SURI or ACCOUNT_JSON_PATH required)"
+    );
+  }
+  const client = getClient(opts.mainchainUrl);
+  if (proxyForAddress) {
+    return new Accountset({
+      client,
+      isProxy: true,
+      seedAddress: proxyForAddress,
+      txSubmitter: keypair
+    });
+  } else {
+    return new Accountset({
+      seedAccount: keypair,
+      client
+    });
+  }
+}
+function addGlobalArgs(program) {
+  for (const command of program.commands) {
+    command.configureHelp({
+      showGlobalOptions: true
+    });
+    for (const nested of command.commands) {
+      nested.configureHelp({
+        showGlobalOptions: true
+      });
+    }
+  }
+}
+function applyEnv(program) {
+  program.parseOptions(process.argv);
+  const { env: env2 } = program.optsWithGlobals();
+  if (env2) {
+    const envPath = Path.resolve(process.cwd(), env2);
+    const res = configDotenv({ path: envPath });
+    if (res.parsed?.ACCOUNT_JSON_PATH) {
+      process.env.ACCOUNT_JSON_PATH = Path.resolve(
+        Path.dirname(envPath),
+        process.env.ACCOUNT_JSON_PATH
+      );
+    }
+  }
+  return env2;
+}
+
+export {
+  accountCli,
+  vaultCli,
+  miningCli,
+  liquidityCli,
+  bitcoinCli,
+  keyringFromFile,
+  saveKeyringPair,
+  globalOptions,
+  buildCli,
+  accountsetFromCli,
+  addGlobalArgs,
+  applyEnv
+};
+//# sourceMappingURL=chunk-BQR6FEVP.js.map