@argonprotocol/mainchain 1.1.0-rc.8 → 1.2.0

package/lib/cli.cjs

@@ -1,3355 +1,14 @@
 #!/bin/env node
 "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 __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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-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/clis/index.ts
-var import_extra_typings6 = require("@commander-js/extra-typings");
 
-// src/clis/accountCli.ts
-var import_extra_typings = require("@commander-js/extra-typings");
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AccountMiners: () => AccountMiners,
-  AccountRegistry: () => AccountRegistry,
-  Accountset: () => Accountset,
-  BidPool: () => BidPool,
-  BitcoinLocks: () => BitcoinLocks,
-  BlockWatch: () => BlockWatch,
-  CohortBidder: () => CohortBidder,
-  ExtrinsicError: () => ExtrinsicError2,
-  JsonExt: () => JsonExt,
-  Keyring: () => import_api.Keyring,
-  MICROGONS_PER_ARGON: () => MICROGONS_PER_ARGON,
-  MiningBids: () => MiningBids,
-  MiningRotations: () => MiningRotations,
-  TxSubmitter: () => TxSubmitter,
-  Vault: () => Vault,
-  VaultMonitor: () => VaultMonitor,
-  WageProtector: () => WageProtector,
-  checkForExtrinsicSuccess: () => checkForExtrinsicSuccess,
-  convertFixedU128ToBigNumber: () => convertFixedU128ToBigNumber,
-  convertPermillToBigNumber: () => convertPermillToBigNumber,
-  createKeyringPair: () => createKeyringPair,
-  decodeAddress: () => import_util_crypto.decodeAddress,
-  dispatchErrorToExtrinsicError: () => dispatchErrorToExtrinsicError,
-  dispatchErrorToString: () => dispatchErrorToString,
-  eventDataToJson: () => eventDataToJson,
-  filterUndefined: () => filterUndefined,
-  formatArgons: () => formatArgons,
-  formatPercent: () => formatPercent,
-  getAuthorFromHeader: () => getAuthorFromHeader,
-  getClient: () => getClient,
-  getTickFromHeader: () => getTickFromHeader,
-  gettersToObject: () => gettersToObject,
-  keyringFromSuri: () => keyringFromSuri,
-  mnemonicGenerate: () => import_util_crypto.mnemonicGenerate,
-  waitForLoad: () => waitForLoad
-});
-
-// src/interfaces/augment-api-consts.ts
-var import_consts = require("@polkadot/api-base/types/consts");
-
-// src/interfaces/augment-api-errors.ts
-var import_errors = require("@polkadot/api-base/types/errors");
-
-// src/interfaces/augment-api-events.ts
-var import_events = require("@polkadot/api-base/types/events");
-
-// src/interfaces/augment-api-query.ts
-var import_storage = require("@polkadot/api-base/types/storage");
-
-// src/interfaces/augment-api-tx.ts
-var import_submittable = require("@polkadot/api-base/types/submittable");
-
-// src/interfaces/augment-api-rpc.ts
-var import_jsonrpc = require("@polkadot/rpc-core/types/jsonrpc");
-
-// src/interfaces/augment-api-runtime.ts
-var import_calls = require("@polkadot/api-base/types/calls");
-
-// src/interfaces/augment-types.ts
-var import_registry = require("@polkadot/types/types/registry");
-
-// src/index.ts
-var import_api = require("@polkadot/api");
-var import_util_crypto = require("@polkadot/util-crypto");
-__reExport(index_exports, require("@polkadot/types-codec/types"));
-
-// src/WageProtector.ts
-var WageProtector = class _WageProtector {
-  constructor(latestCpi) {
-    this.latestCpi = latestCpi;
-  }
-  /**
-   * Converts the base wage to the current wage using the latest CPI snapshot
-   *
-   * @param baseWage The base wage to convert
-   * @returns The protected wage
-   */
-  getProtectedWage(baseWage) {
-    return baseWage * this.latestCpi.argonUsdTargetPrice / this.latestCpi.argonUsdPrice;
-  }
-  /**
-   * Subscribes to the current CPI and calls the callback function whenever the CPI changes
-   * @param client The ArgonClient to use
-   * @param callback The callback function to call when the CPI changes
-   * @returns An object with an unsubscribe function that can be called to stop the subscription
-   */
-  static async subscribe(client, callback) {
-    const unsubscribe = await client.query.priceIndex.current(async (cpi) => {
-      if (cpi.isNone) {
-        return;
-      }
-      const finalizedBlock = await client.rpc.chain.getFinalizedHead();
-      callback(
-        new _WageProtector({
-          argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
-          argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
-          finalizedBlock: finalizedBlock.toU8a(),
-          tick: cpi.value.tick.toBigInt()
-        })
-      );
-    });
-    return { unsubscribe };
-  }
-  /**
-   * Creates a new WageProtector instance by subscribing to the current CPI and waiting for the first value
-   * @param client The ArgonClient to use
-   */
-  static async create(client) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const { unsubscribe } = await _WageProtector.subscribe(client, (x) => {
-          resolve(x);
-          unsubscribe();
-        });
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-};
-
-// src/TxSubmitter.ts
-function logExtrinsicResult(result) {
-  if (process.env.DEBUG) {
-    const json = result.status.toJSON();
-    const status = Object.keys(json)[0];
-    console.debug('Transaction update: "%s"', status, json[status]);
-  }
-}
-var TxSubmitter = class {
-  constructor(client, tx, pair) {
-    this.client = client;
-    this.tx = tx;
-    this.pair = pair;
-  }
-  async feeEstimate(tip) {
-    const { partialFee } = await this.tx.paymentInfo(this.pair, { tip });
-    return partialFee.toBigInt();
-  }
-  async canAfford(options = {}) {
-    const { tip, unavailableBalance } = options;
-    const account = await this.client.query.system.account(this.pair.address);
-    let availableBalance = account.data.free.toBigInt();
-    if (unavailableBalance) {
-      availableBalance -= unavailableBalance;
-    }
-    const existentialDeposit = options.includeExistentialDeposit ? this.client.consts.balances.existentialDeposit.toBigInt() : 0n;
-    const fees = await this.feeEstimate(tip);
-    const totalCharge = fees + (tip ?? 0n);
-    const canAfford = availableBalance > totalCharge + existentialDeposit;
-    return { canAfford, availableBalance, txFee: fees };
-  }
-  async submit(options = {}) {
-    const { logResults } = options;
-    const result = new TxResult(this.client, logResults);
-    let toHuman = this.tx.toHuman().method;
-    let txString = [];
-    let api = formatCall(toHuman);
-    const args = [];
-    if (api === "proxy.proxy") {
-      toHuman = toHuman.args.call;
-      txString.push("Proxy");
-      api = formatCall(toHuman);
-    }
-    if (api.startsWith("utility.batch")) {
-      const calls = toHuman.args.calls.map(formatCall).join(", ");
-      txString.push(`Batch[${calls}]`);
-    } else {
-      txString.push(api);
-      args.push(toHuman.args);
-    }
-    args.unshift(txString.join("->"));
-    if (options.useLatestNonce && !options.nonce) {
-      options.nonce = await this.client.rpc.system.accountNextIndex(
-        this.pair.address
-      );
-    }
-    console.log("Submitting transaction:", ...args);
-    await this.tx.signAndSend(this.pair, options, result.onResult.bind(result));
-    if (options.waitForBlock) {
-      await result.inBlockPromise;
-    }
-    return result;
-  }
-};
-function formatCall(call) {
-  return `${call.section}.${call.method}`;
-}
-var TxResult = class {
-  constructor(client, shouldLog = false) {
-    this.client = client;
-    this.shouldLog = shouldLog;
-    this.inBlockPromise = new Promise((resolve, reject) => {
-      this.inBlockResolve = resolve;
-      this.inBlockReject = reject;
-    });
-    this.finalizedPromise = new Promise((resolve, reject) => {
-      this.finalizedResolve = resolve;
-      this.finalizedReject = reject;
-    });
-    this.inBlockPromise.catch(() => {
-    });
-    this.finalizedPromise.catch(() => {
-    });
-  }
-  inBlockPromise;
-  finalizedPromise;
-  status;
-  events = [];
-  /**
-   * The index of the batch that was interrupted, if any.
-   */
-  batchInterruptedIndex;
-  includedInBlock;
-  /**
-   * The final fee paid for the transaction, including the fee tip.
-   */
-  finalFee;
-  /**
-   * The fee tip paid for the transaction.
-   */
-  finalFeeTip;
-  inBlockResolve;
-  inBlockReject;
-  finalizedResolve;
-  finalizedReject;
-  onResult(result) {
-    this.status = result.status;
-    if (this.shouldLog) {
-      logExtrinsicResult(result);
-    }
-    const { events, status, dispatchError, isFinalized } = result;
-    if (status.isInBlock) {
-      this.includedInBlock = status.asInBlock.toU8a();
-      let encounteredError = dispatchError;
-      let batchErrorIndex;
-      for (const event of events) {
-        this.events.push(event.event);
-        if (this.client.events.utility.BatchInterrupted.is(event.event)) {
-          batchErrorIndex = event.event.data[0].toNumber();
-          this.batchInterruptedIndex = batchErrorIndex;
-          encounteredError = event.event.data[1];
-        }
-        if (this.client.events.transactionPayment.TransactionFeePaid.is(
-          event.event
-        )) {
-          const [_who, actualFee, tip] = event.event.data;
-          this.finalFee = actualFee.toBigInt();
-          this.finalFeeTip = tip.toBigInt();
-        }
-      }
-      if (encounteredError) {
-        const error = dispatchErrorToExtrinsicError(
-          this.client,
-          encounteredError,
-          batchErrorIndex
-        );
-        this.reject(error);
-      } else {
-        this.inBlockResolve(status.asInBlock.toU8a());
-      }
-    }
-    if (isFinalized) {
-      this.finalizedResolve(status.asFinalized);
-    }
-  }
-  reject(error) {
-    this.inBlockReject(error);
-    this.finalizedReject(error);
-  }
-};
-
-// src/utils.ts
-var BN = __toESM(require("bignumber.js"), 1);
-var { ROUND_FLOOR } = BN;
-var MICROGONS_PER_ARGON = 1e6;
-function formatArgons(x) {
-  if (x === void 0 || x === null) return "na";
-  const isNegative = x < 0;
-  let format = (0, BN.default)(x.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
-  if (format.endsWith(".00")) {
-    format = format.slice(0, -3);
-  }
-  return `${isNegative ? "-" : ""}\u20B3${format}`;
-}
-function formatPercent(x) {
-  if (!x) return "na";
-  return `${x.times(100).decimalPlaces(3)}%`;
-}
-function filterUndefined(obj) {
-  return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([_, value]) => value !== void 0 && value !== null
-    )
-  );
-}
-async function gettersToObject(obj) {
-  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
-  const keys = [];
-  for (const key in obj) {
-    keys.push(key);
-  }
-  if (Symbol.iterator in obj) {
-    const iterableToArray = [];
-    for (const item of obj) {
-      iterableToArray.push(await gettersToObject(item));
-    }
-    return iterableToArray;
-  }
-  const result = {};
-  for (const key of keys) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-    if (descriptor && typeof descriptor.value === "function") {
-      continue;
-    }
-    const value = descriptor && descriptor.get ? descriptor.get.call(obj) : obj[key];
-    if (typeof value === "function") continue;
-    result[key] = await gettersToObject(value);
-  }
-  return result;
-}
-function convertFixedU128ToBigNumber(fixedU128) {
-  const decimalFactor = new BN.default(10).pow(new BN.default(18));
-  const rawValue = new BN.default(fixedU128.toString());
-  return rawValue.div(decimalFactor);
-}
-function convertPermillToBigNumber(permill) {
-  const decimalFactor = new BN.default(1e6);
-  const rawValue = new BN.default(permill.toString());
-  return rawValue.div(decimalFactor);
-}
-function eventDataToJson(event) {
-  const obj = {};
-  event.data.forEach((data, index) => {
-    const name = event.data.names?.[index];
-    obj[name ?? `${index}`] = data.toJSON();
-  });
-  return obj;
-}
-function dispatchErrorToString(client, error) {
-  let message = error.toString();
-  if (error.isModule) {
-    const decoded = client.registry.findMetaError(error.asModule);
-    const { docs, name, section } = decoded;
-    message = `${section}.${name}: ${docs.join(" ")}`;
-  }
-  return message;
-}
-var ExtrinsicError2 = class extends Error {
-  constructor(errorCode, details, batchInterruptedIndex) {
-    super(errorCode);
-    this.errorCode = errorCode;
-    this.details = details;
-    this.batchInterruptedIndex = batchInterruptedIndex;
-  }
-  toString() {
-    if (this.batchInterruptedIndex !== void 0) {
-      return `${this.errorCode} ${this.details ?? ""} (Batch interrupted at index ${this.batchInterruptedIndex})`;
-    }
-    return `${this.errorCode} ${this.details ?? ""}`;
-  }
-};
-function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
-  if (error.isModule) {
-    const decoded = client.registry.findMetaError(error.asModule);
-    const { docs, name, section } = decoded;
-    return new ExtrinsicError2(
-      `${section}.${name}`,
-      docs.join(" "),
-      batchInterruptedIndex
-    );
-  }
-  return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
-}
-function checkForExtrinsicSuccess(events, client) {
-  return new Promise((resolve, reject) => {
-    for (const { event } of events) {
-      if (client.events.system.ExtrinsicSuccess.is(event)) {
-        resolve();
-      } else if (client.events.system.ExtrinsicFailed.is(event)) {
-        const [dispatchError] = event.data;
-        let errorInfo = dispatchError.toString();
-        if (dispatchError.isModule) {
-          const decoded = client.registry.findMetaError(dispatchError.asModule);
-          errorInfo = `${decoded.section}.${decoded.name}`;
-        }
-        reject(
-          new Error(
-            `${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`
-          )
-        );
-      }
-    }
-  });
-}
-var JsonExt = class {
-  static stringify(obj, space) {
-    return JSON.stringify(
-      obj,
-      (_, v) => typeof v === "bigint" ? `${v}n` : v,
-      space
-    );
-  }
-  static parse(str) {
-    return JSON.parse(str, (_, v) => {
-      if (typeof v === "string" && v.endsWith("n")) {
-        return BigInt(v.slice(0, -1));
-      }
-      return v;
-    });
-  }
-};
-
-// src/AccountRegistry.ts
-var AccountRegistry = class _AccountRegistry {
-  namedAccounts = /* @__PURE__ */ new Map();
-  me = "me";
-  constructor(name) {
-    if (name) {
-      this.me = name;
-    }
-  }
-  getName(address) {
-    return this.namedAccounts.get(address);
-  }
-  register(address, name) {
-    this.namedAccounts.set(address, name);
-  }
-  static factory = (name) => new _AccountRegistry(name);
-};
-
-// src/Accountset.ts
-var process2 = __toESM(require("process"), 1);
-
-// src/BlockWatch.ts
-var import_nanoevents = require("nanoevents");
-function getTickFromHeader(client, header) {
-  for (const x of header.digest.logs) {
-    if (x.isPreRuntime) {
-      const [engineId, data] = x.asPreRuntime;
-      if (engineId.toString() === "aura") {
-        return client.createType("u64", data).toNumber();
-      }
-    }
-  }
-  return void 0;
-}
-function getAuthorFromHeader(client, header) {
-  for (const x of header.digest.logs) {
-    if (x.isPreRuntime) {
-      const [engineId, data] = x.asPreRuntime;
-      if (engineId.toString() === "pow_") {
-        return client.createType("AccountId32", data).toHuman();
-      }
-    }
-  }
-  return void 0;
-}
-var BlockWatch = class {
-  constructor(mainchain, options = {}) {
-    this.mainchain = mainchain;
-    this.options = options;
-    this.options.shouldLog ??= true;
-    this.options.finalizedBlocks ??= false;
-  }
-  events = (0, import_nanoevents.createNanoEvents)();
-  obligationsById = {};
-  obligationIdByUtxoId = {};
-  unsubscribe;
-  stop() {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = void 0;
-    }
-  }
-  async start() {
-    await this.watchBlocks();
-  }
-  async watchBlocks() {
-    const client = await this.mainchain;
-    const onBlock = async (header) => {
-      try {
-        await this.processBlock(header);
-      } catch (e) {
-        console.error("Error processing block", e);
-      }
-    };
-    if (this.options.finalizedBlocks) {
-      this.unsubscribe = await client.rpc.chain.subscribeFinalizedHeads(onBlock);
-    } else {
-      this.unsubscribe = await client.rpc.chain.subscribeNewHeads(onBlock);
-    }
-  }
-  async processBlock(header) {
-    const client = await this.mainchain;
-    if (this.options.shouldLog) {
-      console.log(`-------------------------------------
-BLOCK #${header.number}, ${header.hash.toHuman()}`);
-    }
-    const blockHash = header.hash;
-    const api = await client.at(blockHash);
-    const isBlockVote = await api.query.blockSeal.isBlockFromVoteSeal();
-    if (!isBlockVote) {
-      console.warn("> Compute reactivated!");
-    }
-    const events = await api.query.system.events();
-    const reloadVaults = /* @__PURE__ */ new Set();
-    let block = void 0;
-    for (const { event, phase } of events) {
-      const data = eventDataToJson(event);
-      if (data.vaultId) {
-        const vaultId = data.vaultId;
-        reloadVaults.add(vaultId);
-      }
-      let logEvent = false;
-      if (event.section === "liquidityPools") {
-        if (client.events.liquidityPools.BidPoolDistributed.is(event)) {
-          const { bidPoolBurned, bidPoolDistributed } = event.data;
-          data.burned = formatArgons(bidPoolBurned.toBigInt());
-          data.distributed = formatArgons(bidPoolDistributed.toBigInt());
-          logEvent = true;
-        } else if (client.events.liquidityPools.NextBidPoolCapitalLocked.is(event)) {
-          const { totalActivatedCapital } = event.data;
-          data.totalActivatedCapital = formatArgons(
-            totalActivatedCapital.toBigInt()
-          );
-          logEvent = true;
-        }
-      } else if (event.section === "bitcoinLocks") {
-        if (client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
-          const { lockPrice, utxoId, accountId, vaultId } = event.data;
-          this.obligationsById[utxoId.toNumber()] = {
-            vaultId: vaultId.toNumber(),
-            amount: lockPrice.toBigInt()
-          };
-          data.lockPrice = formatArgons(lockPrice.toBigInt());
-          data.accountId = accountId.toHuman();
-          reloadVaults.add(vaultId.toNumber());
-        }
-        logEvent = true;
-      } else if (event.section === "mint") {
-        logEvent = true;
-        if (client.events.mint.MiningMint.is(event)) {
-          const { amount } = event.data;
-          data.amount = formatArgons(amount.toBigInt());
-        }
-      } else if (event.section === "miningSlot") {
-        logEvent = true;
-        if (client.events.miningSlot.SlotBidderAdded.is(event)) {
-          data.amount = formatArgons(event.data.bidAmount.toBigInt());
-          this.events.emit("mining-bid", header, {
-            amount: event.data.bidAmount.toBigInt(),
-            accountId: event.data.accountId.toString()
-          });
-        } else if (client.events.miningSlot.SlotBidderDropped.is(event)) {
-          this.events.emit("mining-bid-ousted", header, {
-            accountId: event.data.accountId.toString(),
-            preservedArgonotHold: event.data.preservedArgonotHold.toPrimitive()
-          });
-        }
-      } else if (event.section === "bitcoinUtxos") {
-        logEvent = true;
-        if (client.events.bitcoinUtxos.UtxoVerified.is(event)) {
-          const { utxoId } = event.data;
-          const details = await this.getBitcoinLockDetails(
-            utxoId.toNumber(),
-            blockHash
-          );
-          this.events.emit("bitcoin-verified", header, {
-            utxoId: utxoId.toNumber(),
-            vaultId: details.vaultId,
-            amount: details.amount
-          });
-          data.amount = formatArgons(details.amount);
-          reloadVaults.add(details.vaultId);
-        }
-      } else if (event.section === "system") {
-        if (client.events.system.ExtrinsicFailed.is(event)) {
-          const { dispatchError } = event.data;
-          if (dispatchError.isModule) {
-            const decoded = api.registry.findMetaError(dispatchError.asModule);
-            const { name, section } = decoded;
-            block ??= await client.rpc.chain.getBlock(header.hash);
-            const extrinsicIndex = phase.asApplyExtrinsic.toNumber();
-            const ext = block.block.extrinsics[extrinsicIndex];
-            if (this.options.shouldLog) {
-              console.log(
-                `> [Failed Tx] ${section}.${name} -> ${ext.method.section}.${ext.method.method} (nonce=${ext.nonce})`,
-                ext.toHuman()?.method?.args
-              );
-            }
-          } else {
-            if (this.options.shouldLog) {
-              console.log(`x [Failed Tx] ${dispatchError.toJSON()}`);
-            }
-          }
-        }
-      }
-      if (this.options.shouldLog && logEvent) {
-        console.log(`> ${event.section}.${event.method}`, data);
-      }
-      this.events.emit("event", header, event);
-    }
-    if (reloadVaults.size)
-      this.events.emit("vaults-updated", header, reloadVaults);
-    const tick = getTickFromHeader(client, header);
-    const author = getAuthorFromHeader(client, header);
-    this.events.emit(
-      "block",
-      header,
-      { tick, author },
-      events.map((x) => x.event)
-    );
-  }
-  async getBitcoinLockDetails(utxoId, blockHash) {
-    const client = await this.mainchain;
-    const api = await client.at(blockHash);
-    let obligationId = this.obligationIdByUtxoId[utxoId];
-    if (!obligationId) {
-      const lock = await api.query.bitcoinLocks.locksByUtxoId(utxoId);
-      obligationId = lock.value.obligationId.toNumber();
-      this.obligationIdByUtxoId[utxoId] = obligationId;
-      this.obligationsById[obligationId] = {
-        vaultId: lock.value.vaultId.toNumber(),
-        amount: lock.value.lockPrice.toBigInt()
-      };
-    }
-    return this.obligationsById[obligationId];
-  }
-};
-
-// src/MiningRotations.ts
-var MiningRotations = class {
-  miningConfig;
-  genesisTick;
-  async getForTick(client, tick) {
-    this.miningConfig ??= await client.query.miningSlot.miningConfig().then((x) => ({
-      ticksBetweenSlots: x.ticksBetweenSlots.toNumber(),
-      slotBiddingStartAfterTicks: x.slotBiddingStartAfterTicks.toNumber()
-    }));
-    this.genesisTick ??= await client.query.ticks.genesisTick().then((x) => x.toNumber());
-    const ticksBetweenSlots = this.miningConfig.ticksBetweenSlots;
-    const slot1StartTick = this.genesisTick + this.miningConfig.slotBiddingStartAfterTicks + ticksBetweenSlots;
-    if (tick < slot1StartTick) return 0;
-    const ticksSinceSlot1 = tick - slot1StartTick;
-    return Math.floor(ticksSinceSlot1 / ticksBetweenSlots) + 1;
-  }
-  async getForHeader(client, header) {
-    if (header.number.toNumber() === 0) return 0;
-    const tick = getTickFromHeader(client, header);
-    if (tick === void 0) return void 0;
-    return this.getForTick(client, tick);
-  }
-};
-
-// src/AccountMiners.ts
-var import_nanoevents2 = require("nanoevents");
-var AccountMiners = class _AccountMiners {
-  constructor(accountset, registeredMiners, options = { shouldLog: false }) {
-    this.accountset = accountset;
-    this.options = options;
-    this.miningRotations = new MiningRotations();
-    for (const seat of registeredMiners) {
-      this.trackedAccountsByAddress[seat.address] = {
-        cohortId: seat.cohortId,
-        subaccountIndex: seat.subaccountIndex
-      };
-    }
-  }
-  events = (0, import_nanoevents2.createNanoEvents)();
-  miningRotations;
-  trackedAccountsByAddress = {};
-  async watch() {
-    const blockWatch = new BlockWatch(this.accountset.client, {
-      shouldLog: this.options.shouldLog
-    });
-    blockWatch.events.on("block", this.onBlock.bind(this));
-    await blockWatch.start();
-    return blockWatch;
-  }
-  async onBlock(header, digests, events) {
-    const { author, tick } = digests;
-    if (author) {
-      const voteAuthor = this.trackedAccountsByAddress[author];
-      if (voteAuthor && this.options.shouldLog) {
-        console.log(
-          "> Our vote author",
-          this.accountset.accountRegistry.getName(author)
-        );
-      }
-    } else {
-      console.warn("> No vote author found");
-    }
-    const client = await this.accountset.client;
-    const rotation = await this.miningRotations.getForTick(client, tick);
-    let newMiners;
-    const dataByCohort = { rotation };
-    for (const event of events) {
-      if (client.events.miningSlot.NewMiners.is(event)) {
-        newMiners = {
-          cohortId: event.data.cohortId.toNumber(),
-          addresses: event.data.newMiners.map((x) => x.accountId.toHuman())
-        };
-      }
-      if (client.events.blockRewards.RewardCreated.is(event)) {
-        const { rewards } = event.data;
-        for (const reward of rewards) {
-          const { argons, ownership } = reward;
-          const entry = this.trackedAccountsByAddress[author];
-          if (entry) {
-            dataByCohort[entry.cohortId] ??= {
-              argonsMinted: 0n,
-              argonsMined: 0n,
-              argonotsMined: 0n
-            };
-            dataByCohort[entry.cohortId].argonotsMined += ownership.toBigInt();
-            dataByCohort[entry.cohortId].argonsMined += argons.toBigInt();
-            this.events.emit("mined", header, {
-              author,
-              argons: argons.toBigInt(),
-              argonots: ownership.toBigInt(),
-              cohortId: entry.cohortId,
-              rotation
-            });
-          }
-        }
-      }
-      if (client.events.mint.MiningMint.is(event)) {
-        const { perMiner } = event.data;
-        const amountPerMiner = perMiner.toBigInt();
-        if (amountPerMiner > 0n) {
-          for (const [address, info] of Object.entries(
-            this.trackedAccountsByAddress
-          )) {
-            const { cohortId } = info;
-            dataByCohort[cohortId] ??= {
-              argonsMinted: 0n,
-              argonsMined: 0n,
-              argonotsMined: 0n
-            };
-            dataByCohort[cohortId].argonsMinted += amountPerMiner;
-            this.events.emit("minted", header, {
-              accountId: address,
-              argons: amountPerMiner,
-              cohortId,
-              rotation
-            });
-          }
-        }
-      }
-    }
-    if (newMiners) {
-      this.newCohortMiners(newMiners.cohortId, newMiners.addresses);
-    }
-    return dataByCohort;
-  }
-  newCohortMiners(cohortId, addresses) {
-    for (const [address, info] of Object.entries(
-      this.trackedAccountsByAddress
-    )) {
-      if (info.cohortId === cohortId - 10) {
-        delete this.trackedAccountsByAddress[address];
-      }
-    }
-    for (const address of addresses) {
-      const entry = this.accountset.subAccountsByAddress[address];
-      if (entry) {
-        this.trackedAccountsByAddress[address] = {
-          cohortId,
-          subaccountIndex: entry.index
-        };
-      }
-    }
-  }
-  static async loadAt(accountset, options = {}) {
-    const seats = await accountset.miningSeats(options.blockHash);
-    const registered = seats.filter((x) => x.cohortId !== void 0);
-    return new _AccountMiners(accountset, registered, {
-      shouldLog: options.shouldLog ?? false
-    });
-  }
-};
-
-// src/Accountset.ts
-var Accountset = class {
-  txSubmitterPair;
-  isProxy = false;
-  seedAddress;
-  subAccountsByAddress = {};
-  accountRegistry;
-  client;
-  get addresses() {
-    return [this.seedAddress, ...Object.keys(this.subAccountsByAddress)];
-  }
-  get namedAccounts() {
-    return this.accountRegistry.namedAccounts;
-  }
-  sessionKeyMnemonic;
-  constructor(options) {
-    if ("seedAccount" in options) {
-      this.txSubmitterPair = options.seedAccount;
-      this.seedAddress = options.seedAccount.address;
-      this.isProxy = false;
-    } else {
-      this.isProxy = options.isProxy;
-      this.txSubmitterPair = options.txSubmitter;
-      this.seedAddress = options.seedAddress;
-    }
-    this.sessionKeyMnemonic = options.sessionKeyMnemonic;
-    this.accountRegistry = options.accountRegistry ?? AccountRegistry.factory(options.name);
-    this.client = options.client;
-    const defaultRange = options.subaccountRange ?? getDefaultSubaccountRange();
-    this.accountRegistry.register(
-      this.seedAddress,
-      `${this.accountRegistry.me}//seed`
-    );
-    for (const i of defaultRange) {
-      const pair = this.txSubmitterPair.derive(`//${i}`);
-      this.subAccountsByAddress[pair.address] = { pair, index: i };
-      this.accountRegistry.register(
-        pair.address,
-        `${this.accountRegistry.me}//${i}`
-      );
-    }
-  }
-  async submitterBalance(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const accountData = await api.query.system.account(
-      this.txSubmitterPair.address
-    );
-    return accountData.data.free.toBigInt();
-  }
-  async balance(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const accountData = await api.query.system.account(this.seedAddress);
-    return accountData.data.free.toBigInt();
-  }
-  async totalArgonsAt(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const addresses = this.addresses;
-    const results = await api.query.system.account.multi(addresses);
-    return results.map((account, i) => {
-      const address = addresses[i];
-      return {
-        address,
-        amount: account.data.free.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async totalArgonotsAt(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const addresses = this.addresses;
-    const results = await api.query.ownership.account.multi(addresses);
-    return results.map((account, i) => {
-      const address = addresses[i];
-      return {
-        address,
-        amount: account.free.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async getAvailableMinerAccounts(maxSeats) {
-    const miningSeats = await this.miningSeats();
-    const subaccountRange = [];
-    for (const seat of miningSeats) {
-      if (seat.hasWinningBid) {
-        continue;
-      }
-      if (seat.isLastDay || seat.seat === void 0) {
-        subaccountRange.push({
-          index: seat.subaccountIndex,
-          isRebid: seat.seat !== void 0,
-          address: seat.address
-        });
-        if (subaccountRange.length >= maxSeats) {
-          break;
-        }
-      }
-    }
-    return subaccountRange;
-  }
-  async loadRegisteredMiners(api) {
-    const addresses = Object.keys(this.subAccountsByAddress);
-    const rawIndices = await api.query.miningSlot.accountIndexLookup.multi(addresses);
-    const addressToMiningIndex = {};
-    for (let i = 0; i < addresses.length; i++) {
-      const address = addresses[i];
-      if (rawIndices[i].isNone) continue;
-      addressToMiningIndex[address] = rawIndices[i].value.toNumber();
-    }
-    const indices = Object.values(addressToMiningIndex).filter(
-      (x) => x !== void 0
-    );
-    const indexRegistrations = indices.length ? await api.query.miningSlot.activeMinersByIndex.multi(indices) : [];
-    const registrationBySeatIndex = {};
-    for (let i = 0; i < indices.length; i++) {
-      const seatIndex = indices[i];
-      const registration = indexRegistrations[i];
-      if (registration?.isSome) {
-        registrationBySeatIndex[seatIndex] = {
-          cohortId: registration.value.cohortId.toNumber(),
-          bidAmount: registration.value.bid.toBigInt()
-        };
-      }
-    }
-    const nextCohortId = await api.query.miningSlot.nextCohortId();
-    return addresses.map((address) => {
-      const seat = addressToMiningIndex[address];
-      const registration = registrationBySeatIndex[seat];
-      let isLastDay = false;
-      if (registration?.cohortId) {
-        isLastDay = nextCohortId.toNumber() - registration?.cohortId === 10;
-      }
-      return {
-        ...registration,
-        address,
-        seat,
-        isLastDay,
-        subaccountIndex: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async miningSeats(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const miners = await this.loadRegisteredMiners(api);
-    const nextCohort = await api.query.miningSlot.nextSlotCohort();
-    return miners.map((miner) => {
-      const bid = nextCohort.find((x) => x.accountId.toHuman() === miner.address);
-      return {
-        ...miner,
-        hasWinningBid: !!bid,
-        bidAmount: bid?.bid.toBigInt() ?? miner.bidAmount
-      };
-    });
-  }
-  async bids(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const addresses = Object.keys(this.subAccountsByAddress);
-    const nextCohort = await api.query.miningSlot.nextSlotCohort();
-    const registrationsByAddress = Object.fromEntries(
-      nextCohort.map((x, i) => [x.accountId.toHuman(), { ...x, index: i }])
-    );
-    return addresses.map((address) => {
-      const entry = registrationsByAddress[address];
-      return {
-        address,
-        bidPlace: entry?.index,
-        bidAmount: entry?.bid?.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async consolidate(subaccounts) {
-    const client = await this.client;
-    const accounts = this.getAccountsInRange(subaccounts);
-    const results = [];
-    await Promise.allSettled(
-      accounts.map(({ pair, index }) => {
-        if (!pair) {
-          results.push({
-            index,
-            failedError: new Error(`No keypair for //${index}`)
-          });
-          return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-          client.tx.utility.batchAll([
-            client.tx.balances.transferAll(this.seedAddress, true),
-            client.tx.ownership.transferAll(this.seedAddress, true)
-          ]).signAndSend(pair, (cb) => {
-            logExtrinsicResult(cb);
-            if (cb.dispatchError) {
-              const error = dispatchErrorToString(client, cb.dispatchError);
-              results.push({
-                index,
-                failedError: new Error(
-                  `Error consolidating //${index}: ${error}`
-                )
-              });
-              resolve();
-            }
-            if (cb.isInBlock) {
-              results.push({ index, inBlock: cb.status.asInBlock.toHex() });
-              resolve();
-            }
-          }).catch((e) => {
-            results.push({ index, failedError: e });
-            resolve();
-          });
-        });
-      })
-    );
-    return results;
-  }
-  status(opts) {
-    const { argons, argonots, accountSubset, bids, seats } = opts;
-    const accounts = [
-      {
-        index: "main",
-        address: this.seedAddress,
-        argons: formatArgons(
-          argons.find((x) => x.address === this.seedAddress)?.amount ?? 0n
-        ),
-        argonots: formatArgons(
-          argonots.find((x) => x.address === this.seedAddress)?.amount ?? 0n
-        )
-      }
-    ];
-    for (const [address, { index }] of Object.entries(
-      this.subAccountsByAddress
-    )) {
-      const argonAmount = argons.find((x) => x.address === address)?.amount ?? 0n;
-      const argonotAmount = argonots.find((x) => x.address === address)?.amount ?? 0n;
-      const bid = bids.find((x) => x.address === address);
-      const seat = seats.find((x) => x.address === address)?.seat;
-      const entry = {
-        index: ` //${index}`,
-        address,
-        argons: formatArgons(argonAmount),
-        argonots: formatArgons(argonotAmount),
-        seat,
-        bidPlace: bid?.bidPlace,
-        bidAmount: bid?.bidAmount ?? 0n
-      };
-      if (accountSubset) {
-        entry.isWorkingOn = accountSubset.some((x) => x.address === address);
-      }
-      accounts.push(entry);
-    }
-    return accounts;
-  }
-  async registerKeys(url) {
-    const client = await getClient(url.replace("ws:", "http:"));
-    const keys = this.keys();
-    for (const [name, key] of Object.entries(keys)) {
-      console.log("Registering key", name, key.publicKey);
-      const result = await client.rpc.author.insertKey(
-        name,
-        key.privateKey,
-        key.publicKey
-      );
-      const saved = await client.rpc.author.hasKey(key.publicKey, name);
-      if (!saved) {
-        console.error("Failed to register key", name, key.publicKey);
-        throw new Error(`Failed to register ${name} key ${key.publicKey}`);
-      }
-      console.log(`Registered ${name} key`, result.toHuman());
-    }
-    await client.disconnect();
-  }
-  keys(keysVersion) {
-    let version = keysVersion ?? 0;
-    if (process2.env.KEYS_VERSION) {
-      version = parseInt(process2.env.KEYS_VERSION) ?? 0;
-    }
-    const seedMnemonic = this.sessionKeyMnemonic ?? process2.env.KEYS_MNEMONIC;
-    if (!seedMnemonic) {
-      throw new Error(
-        "KEYS_MNEMONIC environment variable not set. Cannot derive keys."
-      );
-    }
-    const blockSealKey = `${seedMnemonic}//block-seal//${version}`;
-    const granKey = `${seedMnemonic}//grandpa//${version}`;
-    const blockSealAccount = new import_api.Keyring().createFromUri(blockSealKey, {
-      type: "ed25519"
-    });
-    const grandpaAccount = new import_api.Keyring().createFromUri(granKey, {
-      type: "ed25519"
-    });
-    return {
-      seal: {
-        privateKey: blockSealKey,
-        publicKey: `0x${Buffer.from(blockSealAccount.publicKey).toString("hex")}`,
-        rawPublicKey: blockSealAccount.publicKey
-      },
-      gran: {
-        privateKey: granKey,
-        publicKey: `0x${Buffer.from(grandpaAccount.publicKey).toString("hex")}`,
-        rawPublicKey: grandpaAccount.publicKey
-      }
-    };
-  }
-  async tx(tx) {
-    const client = await this.client;
-    return new TxSubmitter(client, tx, this.txSubmitterPair);
-  }
-  /**
-   * Create but don't submit a mining bid transaction.
-   * @param options
-   */
-  async createMiningBidTx(options) {
-    const client = await this.client;
-    const { bidAmount, subaccounts, sendRewardsToSeed } = options;
-    const batch = client.tx.utility.batch(
-      subaccounts.map((x) => {
-        const keys = this.keys();
-        const rewards = sendRewardsToSeed ? { Account: this.seedAddress } : { Owner: null };
-        return client.tx.miningSlot.bid(
-          bidAmount,
-          rewards,
-          {
-            grandpa: keys.gran.rawPublicKey,
-            blockSealAuthority: keys.seal.rawPublicKey
-          },
-          x.address
-        );
-      })
-    );
-    let tx = batch;
-    if (this.isProxy) {
-      tx = client.tx.proxy.proxy(this.seedAddress, "MiningBid", batch);
-    }
-    return new TxSubmitter(client, tx, this.txSubmitterPair);
-  }
-  /**
-   * Create a mining bid. This will create a bid for each account in the given range from the seed account as funding.
-   */
-  async createMiningBids(options) {
-    const accounts = this.getAccountsInRange(options.subaccountRange);
-    const client = await this.client;
-    const submitter = await this.createMiningBidTx({
-      ...options,
-      subaccounts: accounts
-    });
-    const { tip = 0n } = options;
-    const txFee = await submitter.feeEstimate(tip);
-    let minBalance = options.bidAmount * BigInt(accounts.length);
-    let totalFees = tip + 1n + txFee;
-    const seedBalance = await client.query.system.account(this.seedAddress).then((x) => x.data.free.toBigInt());
-    if (!this.isProxy) {
-      minBalance += totalFees;
-    }
-    if (seedBalance < minBalance) {
-      throw new Error(
-        `Insufficient balance to create mining bids. Seed account has ${formatArgons(
-          seedBalance
-        )} but needs ${formatArgons(minBalance)}`
-      );
-    }
-    if (this.isProxy) {
-      const { canAfford, availableBalance } = await submitter.canAfford({
-        tip
-      });
-      if (!canAfford) {
-        throw new Error(
-          `Insufficient balance to pay proxy fees. Proxy account has ${formatArgons(
-            availableBalance
-          )} but needs ${formatArgons(totalFees)}`
-        );
-      }
-    }
-    console.log("Creating bids", {
-      perSeatBid: options.bidAmount,
-      subaccounts: options.subaccountRange,
-      txFee
-    });
-    const txResult = await submitter.submit({
-      tip,
-      useLatestNonce: true
-    });
-    const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
-    return {
-      finalFee: txResult.finalFee,
-      bidError,
-      blockHash: txResult.includedInBlock,
-      successfulBids: txResult.batchInterruptedIndex !== void 0 ? txResult.batchInterruptedIndex : accounts.length
-    };
-  }
-  getAccountsInRange(range) {
-    const entries = new Set(range ?? getDefaultSubaccountRange());
-    return Object.entries(this.subAccountsByAddress).filter(([_, account]) => {
-      return entries.has(account.index);
-    }).map(([address, { pair, index }]) => ({ pair, index, address }));
-  }
-  async watchBlocks(shouldLog = false) {
-    const accountMiners = await AccountMiners.loadAt(this, { shouldLog });
-    await accountMiners.watch();
-    return accountMiners;
-  }
-};
-function getDefaultSubaccountRange() {
-  try {
-    return parseSubaccountRange(process2.env.SUBACCOUNT_RANGE ?? "0-9");
-  } catch {
-    console.error(
-      "Failed to parse SUBACCOUNT_RANGE environment variable. Defaulting to 0-9. Please check the format of the SUBACCOUNT_RANGE variable."
-    );
-    return Array.from({ length: 10 }, (_, i) => i);
-  }
-}
-function parseSubaccountRange(range) {
-  if (!range) {
-    return void 0;
-  }
-  const indices = [];
-  for (const entry of range.split(",")) {
-    if (entry.includes("-")) {
-      const [start, end] = entry.split("-").map((x) => parseInt(x, 10));
-      for (let i = start; i <= end; i++) {
-        indices.push(i);
-      }
-      continue;
-    }
-    const record = parseInt(entry.trim(), 10);
-    if (Number.isNaN(record) || !Number.isInteger(record)) {
-      throw new Error(`Invalid range entry: ${entry}`);
-    }
-    if (Number.isInteger(record)) {
-      indices.push(record);
-    }
-  }
-  return indices;
-}
-
-// src/MiningBids.ts
-var import_console_table_printer = require("console-table-printer");
-var MiningBids = class {
-  constructor(client, shouldLog = true) {
-    this.client = client;
-    this.shouldLog = shouldLog;
-  }
-  nextCohort = [];
-  async maxCohortSize() {
-    const client = await this.client;
-    return client.consts.miningSlot.maxCohortSize.toNumber();
-  }
-  async onCohortChange(options) {
-    const { onBiddingStart, onBiddingEnd } = options;
-    const client = await this.client;
-    let openCohortId = 0;
-    const unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.isNextSlotBiddingOpen,
-        client.query.miningSlot.nextCohortId
-      ],
-      async ([isBiddingOpen, rawNextCohortId]) => {
-        const nextCohortId = rawNextCohortId.toNumber();
-        if (isBiddingOpen.isTrue) {
-          if (openCohortId !== 0) {
-            await onBiddingEnd?.(openCohortId);
-          }
-          openCohortId = nextCohortId;
-          await onBiddingStart?.(nextCohortId);
-        } else {
-          await onBiddingEnd?.(nextCohortId);
-          openCohortId = 0;
-        }
-      }
-    );
-    return { unsubscribe };
-  }
-  async watch(accountNames, blockHash, printFn) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const unsubscribe = await api.query.miningSlot.nextSlotCohort(
-      async (next) => {
-        this.nextCohort = await Promise.all(
-          next.map((x) => this.toBid(accountNames, x))
-        );
-        if (!this.shouldLog) return;
-        console.clear();
-        const block = await client.query.system.number();
-        if (!printFn) {
-          console.log("At block", block.toNumber());
-          this.print();
-        } else {
-          printFn(block.toNumber());
-        }
-      }
-    );
-    return { unsubscribe };
-  }
-  async loadAt(accountNames, blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const nextCohort = await api.query.miningSlot.nextSlotCohort();
-    this.nextCohort = await Promise.all(
-      nextCohort.map((x) => this.toBid(accountNames, x))
-    );
-  }
-  async toBid(accountNames, bid) {
-    return {
-      accountId: bid.accountId.toString(),
-      isOurs: accountNames.get(bid.accountId.toString()) ?? "n",
-      bidAmount: bid.bid.toBigInt()
-    };
-  }
-  print() {
-    const bids = this.nextCohort.map((bid) => {
-      return {
-        account: bid.accountId,
-        isOurs: bid.isOurs,
-        bidAmount: formatArgons(bid.bidAmount)
-      };
-    });
-    if (bids.length) {
-      console.log("\n\nMining Bids:");
-      (0, import_console_table_printer.printTable)(bids);
-    }
-  }
-};
-
-// src/Vault.ts
-var BN2 = __toESM(require("bignumber.js"), 1);
-var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
-var Vault = class {
-  securitization;
-  securitizationRatio;
-  bitcoinLocked;
-  bitcoinPending;
-  terms;
-  operatorAccountId;
-  isClosed;
-  vaultId;
-  pendingTerms;
-  pendingTermsChangeTick;
-  openedDate;
-  constructor(id, vault, tickDuration) {
-    this.securitization = vault.securitization.toBigInt();
-    this.securitizationRatio = convertFixedU128ToBigNumber(
-      vault.securitizationRatio.toBigInt()
-    );
-    this.bitcoinLocked = vault.bitcoinLocked.toBigInt();
-    this.bitcoinPending = vault.bitcoinPending.toBigInt();
-    this.terms = {
-      bitcoinAnnualPercentRate: convertFixedU128ToBigNumber(
-        vault.terms.bitcoinAnnualPercentRate.toBigInt()
-      ),
-      bitcoinBaseFee: vault.terms.bitcoinBaseFee.toBigInt(),
-      liquidityPoolProfitSharing: convertPermillToBigNumber(
-        vault.terms.liquidityPoolProfitSharing.toBigInt()
-      )
-    };
-    this.operatorAccountId = vault.operatorAccountId.toString();
-    this.isClosed = vault.isClosed.valueOf();
-    this.vaultId = id;
-    if (vault.pendingTerms.isSome) {
-      const [tickApply, terms] = vault.pendingTerms.value;
-      this.pendingTermsChangeTick = tickApply.toNumber();
-      this.pendingTerms = {
-        bitcoinAnnualPercentRate: convertFixedU128ToBigNumber(
-          terms.bitcoinAnnualPercentRate.toBigInt()
-        ),
-        bitcoinBaseFee: terms.bitcoinBaseFee.toBigInt(),
-        liquidityPoolProfitSharing: convertPermillToBigNumber(
-          vault.terms.liquidityPoolProfitSharing.toBigInt()
-        )
-      };
-    }
-    this.openedDate = vault.openedTick ? new Date(vault.openedTick.toNumber() * tickDuration) : /* @__PURE__ */ new Date();
-  }
-  availableBitcoinSpace() {
-    const recoverySecuritization = this.recoverySecuritization();
-    return this.securitization - recoverySecuritization - this.bitcoinLocked;
-  }
-  recoverySecuritization() {
-    const reserved = new BN2.default(1).div(this.securitizationRatio);
-    return this.securitization - BigInt(
-      reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2)
-    );
-  }
-  minimumSecuritization() {
-    return BigInt(
-      this.securitizationRatio.multipliedBy(this.bitcoinLocked.toString()).decimalPlaces(0, BN2.default.ROUND_CEIL).toString()
-    );
-  }
-  activatedSecuritization() {
-    const activated = this.bitcoinLocked - this.bitcoinPending;
-    let maxRatio = this.securitizationRatio;
-    if (this.securitizationRatio.toNumber() > 2) {
-      maxRatio = (0, BN2.default)(2);
-    }
-    return BigInt(
-      maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2)
-    );
-  }
-  /**
-   * Returns the amount of Argons available to match per liquidity pool
-   */
-  activatedSecuritizationPerSlot() {
-    const activated = this.activatedSecuritization();
-    return activated / 10n;
-  }
-  calculateBitcoinFee(amount) {
-    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BN2.default.ROUND_CEIL);
-    return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
-  }
-};
-
-// src/VaultMonitor.ts
-var import_console_table_printer2 = require("console-table-printer");
-var import_nanoevents3 = require("nanoevents");
-var VaultMonitor = class {
-  constructor(accountset, alerts = {}, options = {}) {
-    this.accountset = accountset;
-    this.alerts = alerts;
-    this.options = options;
-    this.mainchain = accountset.client;
-    if (options.vaultOnlyWatchMode !== void 0) {
-      this.vaultOnlyWatchMode = options.vaultOnlyWatchMode;
-    }
-    if (options.shouldLog !== void 0) {
-      this.shouldLog = options.shouldLog;
-    }
-    this.miningBids = new MiningBids(this.mainchain, this.shouldLog);
-    this.blockWatch = new BlockWatch(this.mainchain, {
-      shouldLog: this.shouldLog
-    });
-    this.blockWatch.events.on(
-      "vaults-updated",
-      (header, vaultIds) => this.onVaultsUpdated(header.hash, vaultIds)
-    );
-    this.blockWatch.events.on("mining-bid", async (header, _bid) => {
-      await this.miningBids.loadAt(this.accountset.namedAccounts, header.hash);
-      this.printBids(header.hash);
-    });
-    this.blockWatch.events.on("mining-bid-ousted", async (header) => {
-      await this.miningBids.loadAt(this.accountset.namedAccounts, header.hash);
-      this.printBids(header.hash);
-    });
-  }
-  events = (0, import_nanoevents3.createNanoEvents)();
-  vaultsById = {};
-  blockWatch;
-  mainchain;
-  activatedCapitalByVault = {};
-  lastPrintedBids;
-  miningBids;
-  tickDuration = 0;
-  vaultOnlyWatchMode = false;
-  shouldLog = true;
-  stop() {
-    this.blockWatch.stop();
-  }
-  async monitor(justPrint = false) {
-    const client = await this.mainchain;
-    this.tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
-    const blockHeader = await client.rpc.chain.getHeader();
-    const blockHash = blockHeader.hash.toU8a();
-    console.log(
-      `${justPrint ? "Run" : "Started"} at block ${blockHeader.number} - ${blockHeader.hash.toHuman()}`
-    );
-    await this.miningBids.loadAt(this.accountset.namedAccounts, blockHash);
-    const vaults = await client.query.vaults.vaultsById.entries();
-    for (const [storageKey, rawVault] of vaults) {
-      const vaultId = storageKey.args[0].toNumber();
-      this.updateVault(vaultId, rawVault);
-    }
-    await client.query.liquidityPools.nextLiquidityPoolCapital((x) => {
-      this.activatedCapitalByVault = {};
-      for (const entry of x) {
-        const vaultId = entry.vaultId.toNumber();
-        this.activatedCapitalByVault[vaultId] = entry.activatedCapital.toBigInt();
-      }
-      for (const [vaultId, vault] of Object.entries(this.vaultsById)) {
-        const id = Number(vaultId);
-        this.activatedCapitalByVault[id] ??= 0n;
-        this.checkMiningBondAlerts(id, vault);
-      }
-    });
-    this.printVaults();
-    if (!this.vaultOnlyWatchMode && this.shouldLog) {
-      this.miningBids.print();
-    }
-    if (!justPrint) await this.blockWatch.start();
-  }
-  printVaults() {
-    if (!this.shouldLog) return;
-    const vaults = [];
-    for (const [vaultId, vault] of Object.entries(this.vaultsById)) {
-      vaults.push({
-        id: vaultId,
-        btcSpace: `${formatArgons(vault.availableBitcoinSpace())} (${formatArgons(vault.bitcoinPending)} pending)`,
-        btcDeal: `${formatArgons(vault.terms.bitcoinBaseFee)} + ${formatPercent(vault.terms.bitcoinAnnualPercentRate)}`,
-        securitization: `${formatArgons(vault.securitization)} at ${vault.securitizationRatio.toFormat(1)}x`,
-        securActivated: `${formatArgons(vault.activatedSecuritizationPerSlot())}/slot`,
-        liquidPoolDeal: `${formatPercent(vault.terms.liquidityPoolProfitSharing)} sharing`,
-        operator: `${this.accountset.namedAccounts.has(vault.operatorAccountId) ? ` (${this.accountset.namedAccounts.get(vault.operatorAccountId)})` : vault.operatorAccountId}`,
-        state: vault.isClosed ? "closed" : vault.openedDate < /* @__PURE__ */ new Date() ? "open" : "pending"
-      });
-    }
-    if (vaults.length) {
-      if (this.vaultOnlyWatchMode) {
-        console.clear();
-      }
-      console.log("\n\nVaults:");
-      (0, import_console_table_printer2.printTable)(vaults);
-    }
-  }
-  async recheckAfterActive(vaultId) {
-    const activationDate = this.vaultsById[vaultId].openedDate;
-    if (this.shouldLog) {
-      console.log(`Waiting for vault ${vaultId} to activate ${activationDate}`);
-    }
-    await new Promise(
-      (resolve) => setTimeout(resolve, activationDate.getTime() - Date.now())
-    );
-    const client = await this.mainchain;
-    let isReady = false;
-    while (!isReady) {
-      const rawVault = await client.query.vaults.vaultsById(vaultId);
-      if (!rawVault.isSome) return;
-      const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
-      this.vaultsById[vaultId] = vault;
-      if (vault.isClosed) return;
-      if (vault.openedDate < /* @__PURE__ */ new Date()) {
-        isReady = true;
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    this.checkAlerts(vaultId, this.vaultsById[vaultId]);
-  }
-  async onVaultsUpdated(blockHash, vaultIds) {
-    await this.reloadVaultsAt([...vaultIds], blockHash).catch((err) => {
-      console.error(
-        `Failed to reload vault ${[...vaultIds]} at block ${blockHash}:`,
-        err
-      );
-    });
-    this.printVaults();
-  }
-  async reloadVaultsAt(vaultIds, blockHash) {
-    const client = await this.mainchain;
-    const api = await client.at(blockHash);
-    const vaults = await api.query.vaults.vaultsById.multi(vaultIds);
-    for (let i = 0; i < vaultIds.length; i += 1) {
-      this.updateVault(vaultIds[i], vaults[i]);
-    }
-  }
-  updateVault(vaultId, rawVault) {
-    if (rawVault.isNone) return;
-    const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
-    this.vaultsById[vaultId] = vault;
-    if (vault.openedDate > /* @__PURE__ */ new Date()) {
-      void this.recheckAfterActive(vaultId);
-    } else {
-      this.checkAlerts(vaultId, vault);
-    }
-  }
-  checkAlerts(vaultId, vault) {
-    if (this.alerts.bitcoinSpaceAvailable !== void 0) {
-      const availableBitcoinSpace = vault.availableBitcoinSpace();
-      if (availableBitcoinSpace >= this.alerts.bitcoinSpaceAvailable) {
-        console.warn(
-          `Vault ${vaultId} has available bitcoins above ${formatArgons(this.alerts.bitcoinSpaceAvailable)}`
-        );
-        this.events.emit("bitcoin-space-above", vaultId, availableBitcoinSpace);
-      }
-    }
-  }
-  checkMiningBondAlerts(vaultId, vault) {
-    if (this.alerts.liquidityPoolSpaceAvailable === void 0) return;
-    const activatedSecuritization = vault.activatedSecuritizationPerSlot();
-    const capitalization = this.activatedCapitalByVault[vaultId] ?? 0n;
-    const available = activatedSecuritization - capitalization;
-    if (available >= this.alerts.liquidityPoolSpaceAvailable) {
-      this.events.emit("liquidity-pool-space-above", vaultId, available);
-    }
-  }
-  printBids(blockHash) {
-    if (!this.shouldLog) return;
-    if (this.lastPrintedBids === blockHash) return;
-    this.miningBids.print();
-    this.lastPrintedBids = blockHash;
-  }
-};
-
-// src/CohortBidderHistory.ts
-var CohortBidderHistory = class _CohortBidderHistory {
-  constructor(cohortId, subaccounts) {
-    this.cohortId = cohortId;
-    this.subaccounts = subaccounts;
-    this.maxSeatsInPlay = this.subaccounts.length;
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  bidHistory = [];
-  stats = {
-    // number of seats won
-    seatsWon: 0,
-    // sum of argons bid in successful bids
-    totalArgonsBid: 0n,
-    // total number of bids placed (includes 1 per seat)
-    bidsAttempted: 0,
-    // fees including the tip
-    fees: 0n,
-    // Max bid per seat
-    maxBidPerSeat: 0n,
-    // The cost in argonots of each seat
-    argonotsPerSeat: 0n,
-    // The argonot price in USD for cost basis
-    argonotUsdPrice: 0,
-    // The cohort expected argons per block
-    cohortArgonsPerBlock: 0n,
-    // The last block that bids are synced to
-    lastBlockNumber: 0
-  };
-  lastBids = [];
-  myAddresses = /* @__PURE__ */ new Set();
-  maxSeatsInPlay = 0;
-  async init(client) {
-    if (!this.stats.argonotsPerSeat) {
-      const startingStats = await _CohortBidderHistory.getStartingData(client);
-      Object.assign(this.stats, startingStats);
-    }
-  }
-  maybeReducingSeats(maxSeats, reason, historyEntry) {
-    if (this.maxSeatsInPlay > maxSeats) {
-      historyEntry.maxSeatsReductionReason = reason;
-    }
-    this.maxSeatsInPlay = maxSeats;
-    historyEntry.maxSeatsInPlay = maxSeats;
-  }
-  trackChange(next, blockNumber, tick, isLastEntry = false) {
-    let winningBids = 0;
-    let totalArgonsBid = 0n;
-    const nextEntrants = [];
-    for (const x of next) {
-      const bid = x.bid.toBigInt();
-      const address = x.accountId.toHuman();
-      nextEntrants.push({ address, bid });
-      if (this.myAddresses.has(address)) {
-        winningBids++;
-        totalArgonsBid += bid;
-      }
-    }
-    this.stats.seatsWon = winningBids;
-    this.stats.totalArgonsBid = totalArgonsBid;
-    this.stats.lastBlockNumber = Math.max(
-      blockNumber,
-      this.stats.lastBlockNumber
-    );
-    const historyEntry = {
-      cohortId: this.cohortId,
-      blockNumber,
-      tick,
-      bidChanges: [],
-      winningSeats: winningBids,
-      maxSeatsInPlay: this.maxSeatsInPlay
-    };
-    const hasDiffs = JsonExt.stringify(nextEntrants) !== JsonExt.stringify(this.lastBids);
-    if (!isLastEntry || hasDiffs) {
-      this.bidHistory.unshift(historyEntry);
-    }
-    if (hasDiffs) {
-      nextEntrants.forEach(({ address, bid }, i) => {
-        const prevBidIndex = this.lastBids.findIndex(
-          (y) => y.address === address
-        );
-        const entry = {
-          address,
-          bidAmount: bid,
-          bidPosition: i,
-          prevPosition: prevBidIndex === -1 ? null : prevBidIndex
-        };
-        if (prevBidIndex !== -1) {
-          const prevBidAmount = this.lastBids[prevBidIndex].bid;
-          if (prevBidAmount !== bid) {
-            entry.prevBidAmount = prevBidAmount;
-          }
-        }
-        historyEntry.bidChanges.push(entry);
-      });
-      this.lastBids.forEach(({ address, bid }, i) => {
-        const nextBid = nextEntrants.some((y) => y.address === address);
-        if (!nextBid) {
-          historyEntry.bidChanges.push({
-            address,
-            bidAmount: bid,
-            bidPosition: null,
-            prevPosition: i
-          });
-        }
-      });
-      this.lastBids = nextEntrants;
-    }
-    return historyEntry;
-  }
-  onBidResult(historyEntry, param) {
-    const {
-      txFeePlusTip,
-      bidPerSeat,
-      bidsAttempted,
-      successfulBids,
-      blockNumber,
-      bidError
-    } = param;
-    this.stats.fees += txFeePlusTip;
-    this.stats.bidsAttempted += bidsAttempted;
-    if (bidPerSeat > this.stats.maxBidPerSeat) {
-      this.stats.maxBidPerSeat = bidPerSeat;
-    }
-    if (blockNumber !== void 0) {
-      this.stats.lastBlockNumber = Math.max(
-        blockNumber,
-        this.stats.lastBlockNumber
-      );
-    }
-    historyEntry.myBidsPlaced.failureReason = bidError;
-    historyEntry.myBidsPlaced.successfulBids = successfulBids;
-    historyEntry.myBidsPlaced.txFeePlusTip = txFeePlusTip;
-  }
-  static async getStartingData(api) {
-    const argonotPrice = await api.query.priceIndex.current();
-    let argonotUsdPrice = 0;
-    if (argonotPrice.isSome) {
-      argonotUsdPrice = convertFixedU128ToBigNumber(
-        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
-      ).toNumber();
-    }
-    const argonotsPerSeat = await api.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
-    const cohortArgonsPerBlock = await api.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
-    return { argonotsPerSeat, argonotUsdPrice, cohortArgonsPerBlock };
-  }
-};
-
-// src/CohortBidder.ts
-var CohortBidder = class {
-  constructor(accountset, cohortId, subaccounts, options) {
-    this.accountset = accountset;
-    this.cohortId = cohortId;
-    this.subaccounts = subaccounts;
-    this.options = options;
-    this.history = new CohortBidderHistory(cohortId, subaccounts);
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  get client() {
-    return this.accountset.client;
-  }
-  get stats() {
-    return this.history.stats;
-  }
-  get bidHistory() {
-    return this.history.bidHistory;
-  }
-  unsubscribe;
-  pendingRequest;
-  retryTimeout;
-  isStopped = false;
-  needsRebid = false;
-  lastBidTime = 0;
-  history;
-  millisPerTick;
-  myAddresses = /* @__PURE__ */ new Set();
-  async stop() {
-    if (this.isStopped) return this.stats;
-    this.isStopped = true;
-    console.log("Stopping bidder for cohort", this.cohortId);
-    clearTimeout(this.retryTimeout);
-    if (this.unsubscribe) {
-      this.unsubscribe();
-    }
-    const client = await this.client;
-    const [nextCohortId, isBiddingOpen] = await client.queryMulti([
-      client.query.miningSlot.nextCohortId,
-      client.query.miningSlot.isNextSlotBiddingOpen
-    ]);
-    if (nextCohortId.toNumber() === this.cohortId && isBiddingOpen.isTrue) {
-      console.log("Bidding is still open, waiting for it to close");
-      await new Promise(async (resolve) => {
-        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen(
-          (isOpen) => {
-            if (isOpen.isFalse) {
-              unsub();
-              resolve();
-            }
-          }
-        );
-      });
-    }
-    void await this.pendingRequest;
-    let header = await client.rpc.chain.getHeader();
-    while (true) {
-      const api2 = await client.at(header.hash);
-      const cohortId = await api2.query.miningSlot.nextCohortId();
-      if (cohortId.toNumber() === this.cohortId) {
-        break;
-      }
-      header = await client.rpc.chain.getHeader(header.parentHash);
-    }
-    const api = await client.at(header.hash);
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    const cohort = await api.query.miningSlot.nextSlotCohort();
-    this.history.trackChange(cohort, header.number.toNumber(), tick, true);
-    console.log("Bidder stopped", {
-      cohortId: this.cohortId,
-      blockNumber: header.number.toNumber(),
-      tick,
-      cohort: cohort.map((x) => ({
-        address: x.accountId.toHuman(),
-        bid: x.bid.toBigInt()
-      }))
-    });
-    return this.stats;
-  }
-  async start() {
-    console.log(`Starting cohort ${this.cohortId} bidder`, {
-      maxBid: formatArgons(this.options.maxBid),
-      minBid: formatArgons(this.options.minBid),
-      bidIncrement: formatArgons(this.options.bidIncrement),
-      maxBudget: formatArgons(this.options.maxBudget),
-      bidDelay: this.options.bidDelay,
-      subaccounts: this.subaccounts
-    });
-    const client = await this.client;
-    await this.history.init(client);
-    this.millisPerTick ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    this.unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.nextSlotCohort,
-        client.query.miningSlot.nextCohortId
-      ],
-      async ([next, nextCohortId]) => {
-        if (nextCohortId.toNumber() === this.cohortId) {
-          await this.checkSeats(next);
-        }
-      }
-    );
-  }
-  async checkSeats(next) {
-    if (this.isStopped) return;
-    clearTimeout(this.retryTimeout);
-    const client = await this.client;
-    const bestBlock = await client.rpc.chain.getBlockHash();
-    const api = await client.at(bestBlock);
-    const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-    if (this.bidHistory[0]?.blockNumber >= blockNumber) {
-      return;
-    }
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    const historyEntry = this.history.trackChange(next, blockNumber, tick);
-    if (this.pendingRequest) return;
-    const ticksSinceLastBid = Math.floor(
-      (Date.now() - this.lastBidTime) / this.millisPerTick
-    );
-    if (ticksSinceLastBid < this.options.bidDelay) {
-      this.retryTimeout = setTimeout(
-        () => void this.checkCurrentSeats(),
-        this.millisPerTick
-      );
-      return;
-    }
-    console.log(
-      "Checking bids for cohort",
-      this.cohortId,
-      this.subaccounts.map((x) => x.index)
-    );
-    const winningBids = historyEntry.winningSeats;
-    this.needsRebid = winningBids < this.subaccounts.length;
-    if (!this.needsRebid) return;
-    const winningAddresses = new Set(next.map((x) => x.accountId.toHuman()));
-    let lowestBid = -this.options.bidIncrement;
-    if (next.length) {
-      for (let i = next.length - 1; i >= 0; i--) {
-        if (!this.myAddresses.has(next[i].accountId.toHuman())) {
-          lowestBid = next.at(i).bid.toBigInt();
-          break;
-        }
-      }
-    }
-    const MIN_INCREMENT = 10000n;
-    let nextBid = lowestBid + this.options.bidIncrement;
-    if (nextBid < this.options.minBid) {
-      nextBid = this.options.minBid;
-    }
-    if (nextBid > this.options.maxBid) {
-      nextBid = this.options.maxBid;
-    }
-    const fakeTx = await this.accountset.createMiningBidTx({
-      subaccounts: this.subaccounts,
-      bidAmount: nextBid,
-      sendRewardsToSeed: true
-    });
-    let availableBalanceForBids = await api.query.system.account(this.accountset.txSubmitterPair.address).then((x) => x.data.free.toBigInt());
-    for (const bid of next) {
-      if (this.myAddresses.has(bid.accountId.toHuman())) {
-        availableBalanceForBids += bid.bid.toBigInt();
-      }
-    }
-    const tip = this.options.tipPerTransaction ?? 0n;
-    const feeEstimate = await fakeTx.feeEstimate(tip);
-    const feePlusTip = feeEstimate + tip;
-    let budgetForSeats = this.options.maxBudget - feePlusTip;
-    if (budgetForSeats > availableBalanceForBids) {
-      budgetForSeats = availableBalanceForBids - feePlusTip;
-    }
-    if (nextBid < lowestBid) {
-      console.log(
-        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(
-          lowestBid
-        )}.`
-      );
-      this.history.maybeReducingSeats(
-        winningBids,
-        "MaxBidTooLow" /* MaxBidTooLow */,
-        historyEntry
-      );
-      return;
-    }
-    if (nextBid - lowestBid < MIN_INCREMENT) {
-      console.log(
-        `Can't make any more bids for ${this.cohortId} with given constraints.`,
-        {
-          lowestCurrentBid: formatArgons(lowestBid),
-          nextAttemptedBid: formatArgons(nextBid),
-          maxBid: formatArgons(this.options.maxBid)
-        }
-      );
-      this.history.maybeReducingSeats(
-        winningBids,
-        "MaxBidTooLow" /* MaxBidTooLow */,
-        historyEntry
-      );
-      return;
-    }
-    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
-    let accountsToUse = [...this.subaccounts];
-    if (accountsToUse.length > seatsInBudget) {
-      const reason = availableBalanceForBids - feePlusTip < nextBid * BigInt(seatsInBudget) ? "InsufficientFunds" /* InsufficientFunds */ : "MaxBudgetTooLow" /* MaxBudgetTooLow */;
-      this.history.maybeReducingSeats(seatsInBudget, reason, historyEntry);
-      accountsToUse.sort((a, b) => {
-        const isWinningA = winningAddresses.has(a.address);
-        const isWinningB = winningAddresses.has(b.address);
-        if (isWinningA && !isWinningB) return -1;
-        if (!isWinningA && isWinningB) return 1;
-        if (a.isRebid && !b.isRebid) return -1;
-        if (!a.isRebid && b.isRebid) return 1;
-        return a.index - b.index;
-      });
-      accountsToUse.length = seatsInBudget;
-    }
-    if (accountsToUse.length > winningBids) {
-      historyEntry.myBidsPlaced = {
-        bids: accountsToUse.length,
-        bidPerSeat: nextBid,
-        txFeePlusTip: feePlusTip,
-        successfulBids: 0
-      };
-      this.pendingRequest = this.bid(nextBid, accountsToUse, historyEntry);
-    } else if (historyEntry.bidChanges.length === 0) {
-      this.history.bidHistory.shift();
-    }
-    this.needsRebid = false;
-  }
-  async bid(bidPerSeat, subaccounts, historyEntry) {
-    const prevLastBidTime = this.lastBidTime;
-    try {
-      this.lastBidTime = Date.now();
-      const submitter = await this.accountset.createMiningBidTx({
-        subaccounts,
-        bidAmount: bidPerSeat,
-        sendRewardsToSeed: true
-      });
-      const tip = this.options.tipPerTransaction ?? 0n;
-      const txResult = await submitter.submit({
-        tip,
-        useLatestNonce: true
-      });
-      const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
-      let blockNumber;
-      if (txResult.includedInBlock) {
-        const client = await this.client;
-        const api = await client.at(txResult.includedInBlock);
-        blockNumber = await api.query.system.number().then((x) => x.toNumber());
-      }
-      const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
-      this.history.onBidResult(historyEntry, {
-        blockNumber,
-        successfulBids,
-        bidPerSeat,
-        txFeePlusTip: txResult.finalFee ?? 0n,
-        bidsAttempted: subaccounts.length,
-        bidError
-      });
-      console.log("Done creating bids for cohort", {
-        successfulBids,
-        bidPerSeat,
-        blockNumber
-      });
-      if (bidError) throw bidError;
-    } catch (err) {
-      this.lastBidTime = prevLastBidTime;
-      console.error(`Error bidding for cohort ${this.cohortId}:`, err);
-      clearTimeout(this.retryTimeout);
-      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), 1e3);
-    } finally {
-      this.pendingRequest = void 0;
-    }
-    if (this.needsRebid) {
-      this.needsRebid = false;
-      await this.checkCurrentSeats();
-    }
-  }
-  async checkCurrentSeats() {
-    const client = await this.client;
-    const next = await client.query.miningSlot.nextSlotCohort();
-    await this.checkSeats(next);
-  }
-};
-
-// src/BidPool.ts
-var import_console_table_printer3 = require("console-table-printer");
-var EMPTY_TABLE = {
-  headerBottom: { left: " ", mid: " ", other: "\u2500", right: " " },
-  headerTop: { left: " ", mid: " ", other: " ", right: " " },
-  rowSeparator: { left: " ", mid: " ", other: " ", right: " " },
-  tableBottom: { left: " ", mid: " ", other: " ", right: " " },
-  vertical: " "
-};
-var BidPool = class {
-  constructor(client, keypair, accountRegistry = AccountRegistry.factory()) {
-    this.client = client;
-    this.keypair = keypair;
-    this.accountRegistry = accountRegistry;
-    this.blockWatch = new BlockWatch(client, { shouldLog: false });
-  }
-  bidPoolAmount = 0n;
-  nextCohortId = 1;
-  poolVaultCapitalByCohort = {};
-  vaultSecuritization = [];
-  printTimeout;
-  blockWatch;
-  vaultsById = {};
-  tickDuration;
-  lastDistributedCohortId;
-  cohortSubscriptions = {};
-  async onVaultsUpdated(blockHash, vaultIdSet) {
-    const client = await this.client;
-    this.tickDuration ??= (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
-    const api = await client.at(blockHash);
-    const vaultIds = [...vaultIdSet];
-    const rawVaults = await api.query.vaults.vaultsById.multi(vaultIds);
-    for (let i = 0; i < vaultIds.length; i += 1) {
-      const rawVault = rawVaults[i];
-      if (rawVault.isNone) continue;
-      const vaultId = vaultIds[i];
-      this.vaultsById[vaultId] = new Vault(
-        vaultId,
-        rawVault.unwrap(),
-        this.tickDuration
-      );
-    }
-    const vaults = Object.entries(this.vaultsById);
-    const newSecuritization = [];
-    for (const [vaultId, vault] of vaults) {
-      const amount = vault.activatedSecuritizationPerSlot();
-      newSecuritization.push({
-        vaultId: Number(vaultId),
-        bitcoinSpace: vault.availableBitcoinSpace(),
-        activatedSecuritization: amount,
-        vaultSharingPercent: vault.terms.liquidityPoolProfitSharing
-      });
-    }
-    newSecuritization.sort((a, b) => {
-      const diff2 = b.activatedSecuritization - a.activatedSecuritization;
-      if (diff2 !== 0n) return Number(diff2);
-      return a.vaultId - b.vaultId;
-    });
-    this.vaultSecuritization = newSecuritization;
-    this.printDebounce();
-  }
-  async getBidPool() {
-    const client = await this.client;
-    const balanceBytes = await client.rpc.state.call(
-      "MiningSlotApi_bid_pool",
-      ""
-    );
-    const balance = client.createType("U128", balanceBytes);
-    return balance.toBigInt();
-  }
-  async loadAt(blockHash) {
-    const client = await this.client;
-    blockHash ??= (await client.rpc.chain.getHeader()).hash.toU8a();
-    const api = await client.at(blockHash);
-    const rawVaultIds = await api.query.vaults.vaultsById.keys();
-    const vaultIds = rawVaultIds.map((x) => x.args[0].toNumber());
-    this.bidPoolAmount = await this.getBidPool();
-    this.nextCohortId = (await api.query.miningSlot.nextCohortId()).toNumber();
-    const contributors = await api.query.liquidityPools.liquidityPoolsByCohort.entries();
-    for (const [cohortId, funds] of contributors) {
-      const cohortIdNumber = cohortId.args[0].toNumber();
-      this.loadCohortData(cohortIdNumber, funds);
-    }
-    for (const entrant of await api.query.liquidityPools.openLiquidityPoolCapital()) {
-      this.setVaultCohortData(this.nextCohortId, entrant.vaultId.toNumber(), {
-        activatedCapital: entrant.activatedCapital.toBigInt()
-      });
-    }
-    for (const entrant of await api.query.liquidityPools.nextLiquidityPoolCapital()) {
-      this.setVaultCohortData(this.nextCohortId, entrant.vaultId.toNumber(), {
-        activatedCapital: entrant.activatedCapital.toBigInt()
-      });
-    }
-    await this.onVaultsUpdated(blockHash, new Set(vaultIds));
-    this.print();
-  }
-  async watch() {
-    await this.loadAt();
-    await this.blockWatch.start();
-    this.blockWatch.events.on(
-      "vaults-updated",
-      (b, v) => this.onVaultsUpdated(b.hash, v)
-    );
-    const api = await this.client;
-    this.blockWatch.events.on("event", async (_, event) => {
-      if (api.events.liquidityPools.BidPoolDistributed.is(event)) {
-        const { cohortId: rawCohortId } = event.data;
-        this.lastDistributedCohortId = rawCohortId.toNumber();
-        this.bidPoolAmount = await this.getBidPool();
-        this.cohortSubscriptions[rawCohortId.toNumber()]?.();
-        const entrant = await api.query.liquidityPools.liquidityPoolsByCohort(rawCohortId);
-        this.loadCohortData(rawCohortId.toNumber(), entrant);
-        this.printDebounce();
-      }
-      if (api.events.liquidityPools.NextBidPoolCapitalLocked.is(event)) {
-        const { cohortId } = event.data;
-        for (let inc = 0; inc < 2; inc++) {
-          const id = cohortId.toNumber() + inc;
-          if (!this.cohortSubscriptions[id]) {
-            this.cohortSubscriptions[id] = await api.query.liquidityPools.liquidityPoolsByCohort(
-              id,
-              async (entrant) => {
-                this.loadCohortData(id, entrant);
-                this.printDebounce();
-              }
-            );
-          }
-        }
-      }
-    });
-    const unsubscribe = await api.queryMulti(
-      [
-        api.query.miningSlot.nextSlotCohort,
-        api.query.miningSlot.nextCohortId,
-        api.query.liquidityPools.openLiquidityPoolCapital,
-        api.query.liquidityPools.nextLiquidityPoolCapital
-      ],
-      async ([
-        _nextSlotCohort,
-        nextCohortId,
-        openVaultBidPoolCapital,
-        nextPoolCapital
-      ]) => {
-        this.bidPoolAmount = await this.getBidPool();
-        this.nextCohortId = nextCohortId.toNumber();
-        for (const entrant of [
-          ...openVaultBidPoolCapital,
-          ...nextPoolCapital
-        ]) {
-          this.setVaultCohortData(
-            entrant.cohortId.toNumber(),
-            entrant.vaultId.toNumber(),
-            {
-              activatedCapital: entrant.activatedCapital.toBigInt()
-            }
-          );
-        }
-        this.printDebounce();
-      }
-    );
-    return { unsubscribe };
-  }
-  async bondArgons(vaultId, amount, options) {
-    const client = await this.client;
-    const tx = client.tx.liquidityPools.bondArgons(vaultId, amount);
-    const txSubmitter = new TxSubmitter(client, tx, this.keypair);
-    const affordability = await txSubmitter.canAfford({
-      tip: options?.tip,
-      unavailableBalance: amount
-    });
-    if (!affordability.canAfford) {
-      console.warn("Insufficient balance to bond argons to liquidity pool", {
-        ...affordability,
-        argonsNeeded: amount
-      });
-      throw new Error("Insufficient balance to bond argons to liquidity pool");
-    }
-    const result = await txSubmitter.submit({
-      tip: options?.tip,
-      useLatestNonce: true
-    });
-    await result.inBlockPromise;
-    return result;
-  }
-  printDebounce() {
-    if (this.printTimeout) {
-      clearTimeout(this.printTimeout);
-    }
-    this.printTimeout = setTimeout(() => {
-      this.print();
-    }, 100);
-  }
-  getOperatorName(vaultId) {
-    const vault = this.vaultsById[vaultId];
-    return this.accountRegistry.getName(vault.operatorAccountId) ?? vault.operatorAccountId;
-  }
-  print() {
-    console.clear();
-    const lastDistributedCohortId = this.lastDistributedCohortId;
-    const distributedCohort = this.poolVaultCapitalByCohort[this.lastDistributedCohortId ?? -1] ?? {};
-    if (Object.keys(distributedCohort).length > 0) {
-      console.log(`
-
-Distributed (cohort ${lastDistributedCohortId})`);
-      const rows = [];
-      let maxWidth2 = 0;
-      for (const [key, entry] of Object.entries(distributedCohort)) {
-        const { table, width } = this.createBondCapitalTable(
-          entry.earnings ?? 0n,
-          entry.contributors ?? [],
-          `Earnings (shared = ${formatPercent(entry.vaultSharingPercent)})`
-        );
-        if (width > maxWidth2) {
-          maxWidth2 = width;
-        }
-        rows.push({
-          Vault: key,
-          Who: this.getOperatorName(Number(key)),
-          Balances: table
-        });
-      }
-      new import_console_table_printer3.Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Who", alignment: "left" },
-          {
-            name: "Balances",
-            title: "Contributor Balances",
-            alignment: "center",
-            minLen: maxWidth2
-          }
-        ],
-        rows
-      }).printTable();
-    }
-    console.log(
-      `
-
-Active Bid Pool: ${formatArgons(this.bidPoolAmount)} (cohort ${this.nextCohortId})`
-    );
-    const cohort = this.poolVaultCapitalByCohort[this.nextCohortId];
-    if (Object.keys(cohort ?? {}).length > 0) {
-      const rows = [];
-      let maxWidth2 = 0;
-      for (const [key, entry] of Object.entries(cohort)) {
-        const { table, width } = this.createBondCapitalTable(
-          entry.activatedCapital,
-          entry.contributors ?? []
-        );
-        if (width > maxWidth2) {
-          maxWidth2 = width;
-        }
-        rows.push({
-          Vault: key,
-          Who: this.getOperatorName(Number(key)),
-          "Pool Capital": table
-        });
-      }
-      new import_console_table_printer3.Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Who", alignment: "left" },
-          { name: "Pool Capital", alignment: "left", minLen: maxWidth2 }
-        ],
-        rows
-      }).printTable();
-    }
-    const nextPool = this.poolVaultCapitalByCohort[this.nextCohortId + 1] ?? [];
-    let maxWidth = 0;
-    const nextCapital = [];
-    for (const x of this.vaultSecuritization) {
-      const entry = nextPool[x.vaultId] ?? {};
-      const { table, width } = this.createBondCapitalTable(
-        x.activatedSecuritization,
-        entry.contributors ?? []
-      );
-      if (width > maxWidth) {
-        maxWidth = width;
-      }
-      nextCapital.push({
-        Vault: x.vaultId,
-        Owner: this.getOperatorName(x.vaultId),
-        "Bitcoin Space": formatArgons(x.bitcoinSpace),
-        "Activated Securitization": `${formatArgons(x.activatedSecuritization)} / slot`,
-        "Liquidity Pool": `${formatPercent(x.vaultSharingPercent)} profit sharing${table}`
-      });
-    }
-    if (nextCapital.length) {
-      console.log(`
-
-Next (cohort ${this.nextCohortId + 1}):`);
-      new import_console_table_printer3.Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Owner", alignment: "left" },
-          { name: "Bitcoin Space", alignment: "right" },
-          { name: "Activated Securitization", alignment: "right" },
-          { name: "Liquidity Pool", alignment: "left", minLen: maxWidth }
-        ],
-        rows: nextCapital
-      }).printTable();
-    }
-  }
-  setVaultCohortData(cohortId, vaultId, data) {
-    this.poolVaultCapitalByCohort ??= {};
-    this.poolVaultCapitalByCohort[cohortId] ??= {};
-    this.poolVaultCapitalByCohort[cohortId][vaultId] ??= {
-      activatedCapital: data.activatedCapital ?? data.contributors?.reduce((a, b) => a + b.amount, 0n) ?? 0n
-    };
-    Object.assign(
-      this.poolVaultCapitalByCohort[cohortId][vaultId],
-      filterUndefined(data)
-    );
-  }
-  createBondCapitalTable(total, contributors, title = "Total") {
-    const table = new import_console_table_printer3.Table({
-      style: EMPTY_TABLE,
-      columns: [
-        { name: "who", title, minLen: 10, alignment: "right" },
-        {
-          name: "amount",
-          title: formatArgons(total),
-          minLen: 7,
-          alignment: "left"
-        }
-      ]
-    });
-    for (const x of contributors) {
-      table.addRow({
-        who: this.accountRegistry.getName(x.address) ?? x.address,
-        amount: formatArgons(x.amount)
-      });
-    }
-    const str = table.render();
-    const width = str.indexOf("\n");
-    return { table: str, width };
-  }
-  loadCohortData(cohortId, vaultFunds) {
-    for (const [vaultId, fund] of vaultFunds) {
-      const vaultIdNumber = vaultId.toNumber();
-      const contributors = fund.contributorBalances.map(([a, b]) => ({
-        address: a.toHuman(),
-        amount: b.toBigInt()
-      }));
-      if (fund.distributedProfits.isSome) {
-        if (cohortId > (this.lastDistributedCohortId ?? 0)) {
-          this.lastDistributedCohortId = cohortId;
-        }
-      }
-      this.setVaultCohortData(cohortId, vaultIdNumber, {
-        earnings: fund.distributedProfits.isSome ? fund.distributedProfits.unwrap().toBigInt() : void 0,
-        vaultSharingPercent: convertPermillToBigNumber(
-          fund.vaultSharingPercent.toBigInt()
-        ),
-        contributors
-      });
-    }
-  }
-};
-
-// src/BitcoinLocks.ts
-var SATS_PER_BTC = 100000000n;
-var BitcoinLocks = class _BitcoinLocks {
-  constructor(client) {
-    this.client = client;
-  }
-  async getMarketRate(satoshis) {
-    const client = await this.client;
-    const sats = client.createType("U64", satoshis.toString());
-    const marketRate = await client.rpc.state.call(
-      "BitcoinApis_market_rate",
-      sats.toHex(true)
-    );
-    const rate = client.createType("Option<U128>", marketRate);
-    if (!rate.isSome) {
-      throw new Error("Market rate not available");
-    }
-    return rate.value.toBigInt();
-  }
-  async buildBitcoinLockTx(args) {
-    const { vaultId, keypair, bitcoinXpub, tip } = args;
-    let amount = args.amount;
-    const marketRatePerBitcoin = await this.getMarketRate(100000000n);
-    const client = await this.client;
-    const account = await client.query.system.account(keypair.address);
-    const freeBalance = account.data.free.toBigInt();
-    let availableBalance = freeBalance;
-    if (args.reducedBalanceBy) {
-      availableBalance -= args.reducedBalanceBy;
-    }
-    const satoshisNeeded = amount * SATS_PER_BTC / marketRatePerBitcoin - 500n;
-    const tx = client.tx.bitcoinLocks.initialize(
-      vaultId,
-      satoshisNeeded,
-      bitcoinXpub
-    );
-    const existentialDeposit = client.consts.balances.existentialDeposit.toBigInt();
-    const finalTip = tip ?? 0n;
-    const fees = await tx.paymentInfo(keypair.address, { tip });
-    const txFee = fees.partialFee.toBigInt();
-    const tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
-    const rawVault = await client.query.vaults.vaultsById(vaultId);
-    const vault = new Vault(vaultId, rawVault.unwrap(), tickDuration);
-    const btcFee = vault.calculateBitcoinFee(amount);
-    const totalCharge = txFee + finalTip + btcFee;
-    if (amount + totalCharge + existentialDeposit > availableBalance) {
-      throw new Error("Insufficient balance to lock bitcoins");
-    }
-    console.log(
-      `Locking ${satoshisNeeded} satoshis in vault ${vaultId} with market rate of ${formatArgons(marketRatePerBitcoin)}/btc. Xpub: ${bitcoinXpub}`
-    );
-    return { tx, txFee, btcFee, satoshis: satoshisNeeded, freeBalance };
-  }
-  static async waitForSpace(accountset, options) {
-    const { argonAmount, bitcoinXpub, maxLockFee, tip = 0n } = options;
-    const vaults = new VaultMonitor(accountset, {
-      bitcoinSpaceAvailable: argonAmount
-    });
-    return new Promise(async (resolve, reject) => {
-      vaults.events.on("bitcoin-space-above", async (vaultId, amount) => {
-        const vault = vaults.vaultsById[vaultId];
-        const fee = vault.calculateBitcoinFee(amount);
-        console.log(
-          `Vault ${vaultId} has ${formatArgons(amount)} argons available for bitcoin. Lock fee is ${formatArgons(fee)}`
-        );
-        if (maxLockFee !== void 0 && fee > maxLockFee) {
-          console.log(
-            `Skipping vault ${vaultId} due to high lock fee: ${formatArgons(maxLockFee)}`
-          );
-          return;
-        }
-        try {
-          const bitcoinLock = new _BitcoinLocks(accountset.client);
-          const { tx, satoshis, btcFee, txFee } = await bitcoinLock.buildBitcoinLockTx({
-            vaultId,
-            keypair: accountset.txSubmitterPair,
-            amount: argonAmount,
-            bitcoinXpub,
-            tip
-          });
-          const result = await accountset.tx(tx).then((x) => x.submit({ waitForBlock: true, tip }));
-          const client = await accountset.client;
-          const utxoId = result.events.find((x) => client.events.bitcoinLocks.BitcoinLockCreated.is(x))?.data.utxoId?.toNumber();
-          if (!utxoId) {
-            throw new Error("Failed to find UTXO ID");
-          }
-          resolve({
-            satoshis,
-            argons: argonAmount,
-            vaultId,
-            btcFee,
-            txFee,
-            finalizedPromise: result.finalizedPromise,
-            utxoId
-          });
-        } catch (err) {
-          console.error("Error submitting bitcoin lock tx:", err);
-          reject(err);
-        } finally {
-          vaults.stop();
-        }
-      });
-      await vaults.monitor();
-    });
-  }
-};
-
-// src/keyringUtils.ts
-function keyringFromSuri(suri, cryptoType = "sr25519") {
-  return new import_api.Keyring({ type: cryptoType }).createFromUri(suri);
-}
-function createKeyringPair(opts) {
-  const { cryptoType } = opts;
-  const seed = (0, import_util_crypto.mnemonicGenerate)();
-  return keyringFromSuri(seed, cryptoType);
-}
-
-// src/index.ts
-__reExport(index_exports, require("@polkadot/types"));
-__reExport(index_exports, require("@polkadot/types/interfaces"));
-async function waitForLoad() {
-  await (0, import_util_crypto.cryptoWaitReady)();
-}
-async function getClient(host) {
-  let provider;
-  if (host.startsWith("http:")) {
-    provider = new import_api.HttpProvider(host);
-  } else {
-    provider = new import_api.WsProvider(host);
-  }
-  return await import_api.ApiPromise.create({ provider, noInitWarn: true });
-}
-
-// src/clis/accountCli.ts
-var import_console_table_printer4 = require("console-table-printer");
-var import_util_crypto2 = require("@polkadot/util-crypto");
-var import_node_fs = require("fs");
-var process3 = __toESM(require("process"), 1);
-function accountCli() {
-  const program2 = new import_extra_typings.Command("accounts").description(
-    "Manage subaccounts from a single keypair"
-  );
-  program2.command("watch").description("Watch for blocks closed by subaccounts").action(async () => {
-    const accountset = await accountsetFromCli(program2);
-    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);
-    });
-  });
-  program2.command("list", { isDefault: true }).description("Show subaccounts").option("--addresses", "Just show a list of ids").action(async ({ addresses }) => {
-    const { subaccounts } = globalOptions(program2);
-    const accountset = await accountsetFromCli(program2);
-    if (addresses) {
-      const addresses2 = accountset.addresses;
-      console.log(addresses2.join(","));
-      process3.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
-    });
-    (0, import_console_table_printer4.printTable)(status);
-    process3.exit(0);
-  });
-  program2.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(program2);
-    const accountset = await accountsetFromCli(program2);
-    process3.env.KEYS_MNEMONIC ||= (0, import_util_crypto.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: process3.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";
-      }
-    }
-    (0, import_node_fs.writeFileSync)(path, envfile);
-    console.log("Created env file at", path);
-    process3.exit();
-  });
-  program2.command("new-key-seed").description("Create a new mnemonic for runtime keys").action(async () => {
-    await (0, import_util_crypto2.cryptoWaitReady)();
-    const mnemonic = (0, import_util_crypto.mnemonicGenerate)();
-    console.log(
-      "New mnemonic (add this to your .env as KEYS_MNEMONIC):",
-      mnemonic
-    );
-    process3.exit(0);
-  });
-  program2.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(program2);
-    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);
-    }
-    process3.exit();
-  });
-  program2.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(program2);
-    const result = await accountset.consolidate(subaccounts);
-    (0, import_console_table_printer4.printTable)(result);
-    process3.exit(0);
-  });
-  return program2;
-}
-
-// src/clis/index.ts
-var import_dotenv = require("dotenv");
-var import_node_path = __toESM(require("path"), 1);
-
-// src/clis/vaultCli.ts
-var import_extra_typings2 = require("@commander-js/extra-typings");
-function vaultCli() {
-  const program2 = new import_extra_typings2.Command("vaults").description(
-    "Monitor vaults and manage securitization"
-  );
-  program2.command("list", { isDefault: true }).description("Show current state of vaults").action(async () => {
-    const accountset = await accountsetFromCli(program2);
-    const vaults = new VaultMonitor(accountset, void 0, {
-      vaultOnlyWatchMode: true
-    });
-    await vaults.monitor(true);
-    process.exit(0);
-  });
-  program2.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(program2);
-    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);
-    }
-  });
-  program2.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(program2);
-    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 program2;
-}
-
-// src/clis/miningCli.ts
-var import_extra_typings3 = require("@commander-js/extra-typings");
-var import_console_table_printer5 = require("console-table-printer");
-function miningCli() {
-  const program2 = new import_extra_typings3.Command("mining").description(
-    "Watch mining seats or setup bidding"
-  );
-  program2.command("list", { isDefault: true }).description("Monitor all miners").action(async () => {
-    const accountset = await accountsetFromCli(program2);
-    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}`);
-        (0, import_console_table_printer5.printTable)(
-          toPrint.map((x) => ({
-            ...x,
-            bid: x.bid ? formatArgons(x.bid) : "-",
-            cohort: x.cohort,
-            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
-    );
-    const maxMiners = api.consts.miningSlot.maxMiners.toNumber();
-    const seatIndices = new Array(maxMiners).fill(0).map((_, i) => i);
-    console.log("Watching miners...");
-    const unsub = await api.query.miningSlot.nextCohortId(
-      async (nextCohortId) => {
-        const entries = await api.query.miningSlot.activeMinersByIndex.entries();
-        const block = await api.query.system.number();
-        const seatsWithMiner = new Set(seatIndices);
-        for (const [rawIndex, maybeMiner] of entries) {
-          const index = rawIndex.args[0].toNumber();
-          if (!maybeMiner.isSome) {
-            continue;
-          }
-          seatsWithMiner.delete(index);
-          const miner = maybeMiner.unwrap();
-          const address = miner.accountId.toHuman();
-          const cohortId = miner.cohortId.toNumber();
-          lastMiners[index] = {
-            miner: accountset.namedAccounts.get(address) ?? address,
-            bid: miner.bid.toBigInt(),
-            cohort: cohortId,
-            isLastDay: nextCohortId.toNumber() - cohortId === 10
-          };
-        }
-        for (const index of seatsWithMiner) {
-          lastMiners[index] = {
-            miner: "none"
-          };
-        }
-        print(block.toNumber());
-      }
-    );
-    process.on("SIGINT", () => {
-      unsubscribe();
-      unsub();
-      process.exit(0);
-    });
-  });
-  program2.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(program2, 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", {
-            cohortId: cohortBidder.cohortId,
-            ...stats
-          });
-          cohortBidder = void 0;
-          if (!runContinuous) {
-            unsubscribe2();
-            process.exit();
-          }
-        }
-      };
-      const { unsubscribe } = await miningBids.onCohortChange({
-        async onBiddingEnd(cohortId) {
-          if (cohortBidder?.cohortId === cohortId) {
-            await stopBidder(unsubscribe);
-          }
-        },
-        async onBiddingStart(cohortId) {
-          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?.cohortId !== cohortId) {
-            await stopBidder(unsubscribe);
-          }
-          cohortBidder = new CohortBidder(
-            accountset,
-            cohortId,
-            subaccountRange,
-            {
-              maxBid: maxBidAmount,
-              minBid: BigInt((minBid ?? 0) * MICROGONS_PER_ARGON),
-              bidIncrement: BigInt(
-                Math.floor(bidIncrement * MICROGONS_PER_ARGON)
-              ),
-              maxBudget: maxBalanceToUse,
-              bidDelay
-            }
-          );
-          await cohortBidder.start();
-        }
-      });
-    }
-  );
-  program2.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(program2);
-    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(program2);
-      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 program2;
-}
-
-// src/clis/liquidityCli.ts
-var import_extra_typings4 = require("@commander-js/extra-typings");
-function liquidityCli() {
-  const program2 = new import_extra_typings4.Command("liquidity-pools").description(
-    "Monitor or bond to liquidity pools"
-  );
-  program2.command("list", { isDefault: true }).description("Show or watch the vault bid pool rewards").action(async () => {
-    const accountset = await accountsetFromCli(program2);
-    const bidPool = new BidPool(
-      accountset.client,
-      accountset.txSubmitterPair
-    );
-    await bidPool.watch();
-  });
-  program2.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(program2);
-    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();
-  });
-  program2.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,
-    100
-  ).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(program2);
-    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 program2;
-}
-
-// src/clis/bitcoinCli.ts
-var import_extra_typings5 = require("@commander-js/extra-typings");
-function bitcoinCli() {
-  const program2 = new import_extra_typings5.Command("bitcoin").description("Wait for bitcoin space");
-  program2.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(program2);
-    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();
-  });
-  program2.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(program2);
-    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 program2;
-}
-
-// src/clis/keyringStore.ts
-var import_node_fs2 = require("fs");
-var os = __toESM(require("os"), 1);
-var { readFile, writeFile } = import_node_fs2.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 import_api.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(program2) {
-  return program2.optsWithGlobals();
-}
-function buildCli() {
-  return new import_extra_typings6.Command("Argon CLI").option("-e, --env <path>", "The path to the account .env file to load").addOption(
-    new import_extra_typings6.Option("-u, --mainchain-url <url>", "The mainchain URL to connect to").default("wss://rpc.argon.network").env("MAINCHAIN_URL")
-  ).addOption(
-    new import_extra_typings6.Option(
-      "--account-file-path <jsonPath>",
-      "The path to your json seed file from polkadotjs"
-    ).env("ACCOUNT_JSON_PATH")
-  ).addOption(
-    new import_extra_typings6.Option(
-      "--account-suri <secretUri>",
-      "A secret uri (suri) to use for the account"
-    ).env("ACCOUNT_SURI")
-  ).addOption(
-    new import_extra_typings6.Option(
-      "--account-passphrase <password>",
-      "The password for your seed file"
-    ).env("ACCOUNT_PASSPHRASE")
-  ).addOption(
-    new import_extra_typings6.Option(
-      "--account-passphrase-file <path>",
-      "The path to a password for your seed file"
-    )
-  ).addOption(
-    new import_extra_typings6.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(program2, proxyForAddress) {
-  const opts = program2.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(program2) {
-  for (const command of program2.commands) {
-    command.configureHelp({
-      showGlobalOptions: true
-    });
-    for (const nested of command.commands) {
-      nested.configureHelp({
-        showGlobalOptions: true
-      });
-    }
-  }
-}
-function applyEnv(program2) {
-  program2.parseOptions(process.argv);
-  const { env: env3 } = program2.optsWithGlobals();
-  if (env3) {
-    const envPath = import_node_path.default.resolve(process.cwd(), env3);
-    const res = (0, import_dotenv.configDotenv)({ path: envPath });
-    if (res.parsed?.ACCOUNT_JSON_PATH) {
-      process.env.ACCOUNT_JSON_PATH = import_node_path.default.relative(
-        envPath,
-        process.env.ACCOUNT_JSON_PATH
-      );
-    }
-  }
-  return env3;
-}
+var _chunkEY3HYZMJcjs = require('./chunk-EY3HYZMJ.cjs');
+require('./chunk-CHGCEO2U.cjs');
 
 // src/cli.ts
-var program = buildCli();
-addGlobalArgs(program);
-applyEnv(program);
+var program = _chunkEY3HYZMJcjs.buildCli.call(void 0, );
+_chunkEY3HYZMJcjs.addGlobalArgs.call(void 0, program);
+_chunkEY3HYZMJcjs.applyEnv.call(void 0, program);
 program.parseAsync(process.argv).catch(console.error);
 //# sourceMappingURL=cli.cjs.map