@argonprotocol/mainchain 1.0.18 → 1.1.0-rc.2

package/lib/index.js

@@ -0,0 +1,2333 @@
+// src/interfaces/augment-api-consts.ts
+import "@polkadot/api-base/types/consts";
+
+// src/interfaces/augment-api-errors.ts
+import "@polkadot/api-base/types/errors";
+
+// src/interfaces/augment-api-events.ts
+import "@polkadot/api-base/types/events";
+
+// src/interfaces/augment-api-query.ts
+import "@polkadot/api-base/types/storage";
+
+// src/interfaces/augment-api-tx.ts
+import "@polkadot/api-base/types/submittable";
+
+// src/interfaces/augment-api-rpc.ts
+import "@polkadot/rpc-core/types/jsonrpc";
+
+// src/interfaces/augment-api-runtime.ts
+import "@polkadot/api-base/types/calls";
+
+// src/interfaces/augment-types.ts
+import "@polkadot/types/types/registry";
+
+// src/index.ts
+import { ApiPromise, HttpProvider, Keyring, WsProvider } from "@polkadot/api";
+import {
+  cryptoWaitReady as cryptoWaitReady2,
+  decodeAddress,
+  mnemonicGenerate
+} from "@polkadot/util-crypto";
+
+// 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/utils.ts
+import BigNumber, * as BN from "bignumber.js";
+var { ROUND_FLOOR } = BN;
+function formatArgons(x) {
+  const isNegative = x < 0;
+  let format = BigNumber(x.toString()).abs().div(1e6).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 BigNumber(10).pow(new BigNumber(18));
+  const rawValue = new BigNumber(fixedU128.toString());
+  return rawValue.div(decimalFactor);
+}
+function convertPermillToBigNumber(permill) {
+  const decimalFactor = new BigNumber(1e6);
+  const rawValue = new BigNumber(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;
+}
+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/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 = dispatchErrorToString(this.client, encounteredError);
+        if (batchErrorIndex) {
+          this.reject(
+            new Error(`Error in batch#${batchErrorIndex}: ${error.toString()}`)
+          );
+        }
+        this.reject(new Error(`Transaction failed: ${error}`));
+      } else {
+        this.inBlockResolve(status.asInBlock.toU8a());
+      }
+    }
+    if (isFinalized) {
+      this.finalizedResolve(status.asFinalized);
+    }
+  }
+  reject(error) {
+    this.inBlockReject(error);
+    this.finalizedReject(error);
+  }
+};
+
+// 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
+import * as process2 from "node:process";
+
+// src/AccountMiners.ts
+import EventEmitter2 from "node:events";
+
+// src/BlockWatch.ts
+import EventEmitter from "node:events";
+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 = new EventEmitter();
+  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 slot1Tick = this.genesisTick + this.miningConfig.slotBiddingStartAfterTicks;
+    const ticksSinceMiningStart = tick - slot1Tick;
+    return Math.floor(ticksSinceMiningStart / ticksBetweenSlots);
+  }
+  async getForHeader(client, header) {
+    const tick = getTickFromHeader(client, header);
+    if (tick === void 0) return void 0;
+    return this.getForTick(client, tick);
+  }
+};
+
+// src/AccountMiners.ts
+var AccountMiners = class {
+  constructor(accountset, options = { shouldLog: false }) {
+    this.accountset = accountset;
+    this.options = options;
+    this.miningRotations = new MiningRotations();
+  }
+  events = new EventEmitter2();
+  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;
+  }
+  loadCurrentState(seats) {
+    for (const seat of seats) {
+      this.trackedAccountsByAddress[seat.address] = {
+        cohortId: seat.cohortId,
+        subaccountIndex: seat.subaccountIndex
+      };
+    }
+  }
+  async loadAt(blockHash) {
+    const seats = await this.accountset.miningSeats(blockHash);
+    this.loadCurrentState(seats.filter((x) => x.cohortId !== void 0));
+  }
+  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) {
+        console.log("new miners has subaccount", address);
+        this.trackedAccountsByAddress[address] = {
+          cohortId,
+          subaccountIndex: entry.index
+        };
+      }
+    }
+  }
+};
+
+// src/Accountset.ts
+var Accountset = class _Accountset {
+  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 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 miningSeats(blockHash) {
+    const client = await this.client;
+    const api = blockHash ? await client.at(blockHash) : client;
+    const addresses = Object.keys(this.subAccountsByAddress);
+    const rawIndices = await api.query.miningSlot.accountIndexLookup.multi(addresses);
+    const addressToIndex = {};
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      if (rawIndices[i].isNone) continue;
+      addressToIndex[address] = rawIndices[i].value.toNumber();
+    }
+    const indices = Object.values(addressToIndex).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(),
+          bid: registration.value.bid.toBigInt()
+        };
+      }
+    }
+    const nextCohortId = await api.query.miningSlot.nextCohortId();
+    const nextCohort = await api.query.miningSlot.nextSlotCohort();
+    return addresses.map((address) => {
+      const seat = addressToIndex[address];
+      const registration = registrationBySeatIndex[seat];
+      let isLastDay = false;
+      if (registration) {
+        isLastDay = nextCohortId.toNumber() - registration.cohortId === 10;
+      }
+      return {
+        address,
+        seat,
+        subaccountIndex: this.subAccountsByAddress[address]?.index ?? Number.NaN,
+        hasWinningBid: nextCohort.some((x) => x.accountId.toHuman() === address),
+        cohortId: registration?.cohortId,
+        bidAmount: registration?.bid,
+        isLastDay
+      };
+    });
+  }
+  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 Keyring().createFromUri(blockSealKey, {
+      type: "ed25519"
+    });
+    const grandpaAccount = new 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 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;
+    let tip = options.tip ?? 0n;
+    const batch = client.tx.utility.batch(
+      accounts.map((x) => {
+        const keys = this.keys();
+        const rewards = options.sendRewardsToSeed ? { Account: this.seedAddress } : { Owner: null };
+        return client.tx.miningSlot.bid(
+          options.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);
+    }
+    const submitter = new TxSubmitter(client, tx, this.txSubmitterPair);
+    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 = new AccountMiners(this, { shouldLog });
+    await accountMiners.loadAt();
+    await accountMiners.watch();
+    return accountMiners;
+  }
+  static async fromCli(program, proxyForAddress) {
+    const parentOptions = program.parent?.optsWithGlobals();
+    const keypair = await keyringFromCli(parentOptions);
+    const client = getClient(parentOptions.mainchainUrl);
+    if (proxyForAddress) {
+      return new _Accountset({
+        client,
+        isProxy: true,
+        seedAddress: proxyForAddress,
+        txSubmitter: keypair
+      });
+    } else {
+      return new _Accountset({
+        seedAccount: keypair,
+        client
+      });
+    }
+  }
+};
+function getDefaultSubaccountRange() {
+  return parseSubaccountRange(process2.env.SUBACCOUNT_RANGE ?? "0-9");
+}
+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
+import { printTable } from "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:");
+      printTable(bids);
+    }
+  }
+};
+
+// src/Vault.ts
+import BigNumber2, * as BN2 from "bignumber.js";
+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 BigNumber2(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, BigNumber2.ROUND_CEIL).toString()
+    );
+  }
+  activatedSecuritization() {
+    const activated = this.bitcoinLocked - this.bitcoinPending;
+    let maxRatio = this.securitizationRatio;
+    if (this.securitizationRatio.toNumber() > 2) {
+      maxRatio = BigNumber2(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(BigNumber2.ROUND_CEIL);
+    return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
+  }
+};
+
+// src/VaultMonitor.ts
+import EventEmitter3 from "node:events";
+import { printTable as printTable2 } from "console-table-printer";
+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 = new EventEmitter3();
+  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:");
+      printTable2(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/CohortBidder.ts
+var CohortBidder = class {
+  constructor(accountset, cohortId, subaccounts, options) {
+    this.accountset = accountset;
+    this.cohortId = cohortId;
+    this.subaccounts = subaccounts;
+    this.options = options;
+    this.subaccounts.forEach((x) => {
+      this.allAddresses.add(x.address);
+    });
+  }
+  get client() {
+    return this.accountset.client;
+  }
+  stats = {
+    // number of seats won
+    seats: 0,
+    // sum of argons bid in successful bids
+    totalArgonsBid: 0n,
+    // total number of bids placed (includes 1 per seat)
+    bids: 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
+  };
+  unsubscribe;
+  pendingRequest;
+  retryTimeout;
+  isStopped = false;
+  needsRebid = false;
+  lastBidTime = 0;
+  millisPerTick;
+  allAddresses = /* @__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 [nextCohort, nextCohortId] = await new Promise(async (resolve) => {
+      const unsub = await client.queryMulti(
+        [
+          client.query.miningSlot.nextSlotCohort,
+          client.query.miningSlot.nextCohortId,
+          client.query.miningSlot.isNextSlotBiddingOpen
+        ],
+        ([nextCohort2, nextCohortId2, isBiddingStillOpen]) => {
+          if (nextCohortId2.toNumber() !== this.cohortId || isBiddingStillOpen.isFalse) {
+            unsub();
+            resolve([nextCohort2, nextCohortId2]);
+          }
+        }
+      );
+    });
+    void await this.pendingRequest;
+    if (nextCohortId.toNumber() === this.cohortId) {
+      console.log("Bidder updating stats with bid queue");
+      this.updateStats(nextCohort);
+    } else {
+      const bestBlock = await client.rpc.chain.getBlockHash();
+      const api = await client.at(bestBlock);
+      const wonIndices = await api.query.miningSlot.accountIndexLookup.multi([...this.allAddresses]).then((x) => x.filter((x2) => x2.isSome).map((x2) => x2.value));
+      const wonSeats = await api.query.miningSlot.activeMinersByIndex.multi(wonIndices).then(
+        (x) => x.filter(
+          (x2) => x2.isSome && x2.value.cohortId.toNumber() === this.cohortId
+        ).map((x2) => x2.value)
+      );
+      console.log("Bidder updating stats with finalized cohort");
+      this.updateStats(wonSeats);
+    }
+    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),
+      maxBalance: formatArgons(this.options.maxBalance),
+      bidDelay: this.options.bidDelay,
+      subaccounts: this.subaccounts
+    });
+    const client = await this.client;
+    const argonotPrice = await client.query.priceIndex.current();
+    if (argonotPrice.isSome) {
+      this.stats.argonotUsdPrice = convertFixedU128ToBigNumber(
+        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
+      ).toNumber();
+    }
+    this.millisPerTick ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    this.stats.argonotsPerSeat = await client.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
+    this.stats.cohortArgonsPerBlock = await client.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
+    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);
+        }
+      }
+    );
+  }
+  updateStats(next) {
+    let seats = 0;
+    let totalArgonsBid = 0n;
+    for (const x of next) {
+      if (this.allAddresses.has(x.accountId.toHuman())) {
+        seats++;
+        totalArgonsBid += x.bid.toBigInt();
+      }
+    }
+    this.stats.seats = seats;
+    this.stats.totalArgonsBid = totalArgonsBid;
+  }
+  async checkSeats(next) {
+    if (this.isStopped || this.pendingRequest) return;
+    const ticksSinceLastBid = Math.floor(
+      (Date.now() - this.lastBidTime) / this.millisPerTick
+    );
+    if (ticksSinceLastBid < this.options.bidDelay) {
+      return;
+    }
+    console.log(
+      "Checking seats for cohort",
+      this.cohortId,
+      this.subaccounts.map((x) => x.index)
+    );
+    this.updateStats(next);
+    this.needsRebid = this.subaccounts.some(
+      (x) => !next.some((y) => y.accountId.toHuman() === x.address)
+    );
+    if (!this.needsRebid) return;
+    const lowestBid = next.at(-1)?.bid.toBigInt() ?? -this.options.bidIncrement;
+    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;
+      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)
+          }
+        );
+        return;
+      }
+    }
+    if (nextBid < lowestBid) {
+      console.log(
+        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(
+          lowestBid
+        )}.`
+      );
+      return;
+    }
+    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(this.options.maxBalance / nextBid);
+    if (seatsInBudget <= 0) {
+      console.log(
+        `Can't afford any seats at ${formatArgons(nextBid)}. Would exceed our max balance of ${formatArgons(this.options.maxBalance)}.`
+      );
+      return;
+    }
+    if (this.subaccounts.length > seatsInBudget) {
+      const toKeep = [];
+      for (const account of this.subaccounts) {
+        if (toKeep.length >= seatsInBudget) break;
+        if (account.isRebid) {
+          toKeep.push(account);
+        }
+      }
+      for (const account of this.subaccounts) {
+        if (toKeep.length >= seatsInBudget) break;
+        if (!account.isRebid) {
+          toKeep.push(account);
+        }
+      }
+      const removedIndices = this.subaccounts.filter((x) => !toKeep.some((y) => y.index === x.index)).map((x) => x.index);
+      this.subaccounts = toKeep;
+      console.log("Had to remove some subaccounts to fit in budget:", {
+        removedIndices,
+        seatsInBudget,
+        budget: formatArgons(this.options.maxBalance)
+      });
+    }
+    this.pendingRequest = this.bid(
+      nextBid,
+      this.subaccounts.map((x) => x.index)
+    );
+    this.needsRebid = false;
+  }
+  async bid(bidPerSeat, subaccountRange) {
+    if (!subaccountRange.length) return;
+    const prevLastBidTime = this.lastBidTime;
+    try {
+      this.lastBidTime = Date.now();
+      const result = await this.accountset.createMiningBids({
+        subaccountRange,
+        bidAmount: bidPerSeat,
+        sendRewardsToSeed: true
+      });
+      this.stats.fees += result.finalFee ?? 0n;
+      this.stats.bids += subaccountRange.length;
+      if (bidPerSeat > this.stats.maxBidPerSeat) {
+        this.stats.maxBidPerSeat = bidPerSeat;
+      }
+      console.log("Done creating bids for cohort", this.cohortId);
+      if (result.bidError) throw result.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
+import { Table } from "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 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 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 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 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
+import { promises } from "node:fs";
+import os from "node:os";
+var { readFile, writeFile } = promises;
+async function keyringFromCli(opts) {
+  if (opts.accountSuri) {
+    return keyringFromSuri(opts.accountSuri);
+  }
+  if (opts.accountFilePath) {
+    return keyringFromFile({
+      filePath: opts.accountFilePath,
+      passphrase: opts.accountPassphrase
+    });
+  }
+  throw new Error(
+    "No ACCOUNT account loaded (either ACCOUNT_SURI or ACCOUNT_JSON_PATH required)"
+  );
+}
+function keyringFromSuri(suri) {
+  return new Keyring({ type: "sr25519" }).createFromUri(suri);
+}
+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"));
+  const mainAccount = new Keyring().createFromJson(json);
+  mainAccount.decodePkcs8(opts.passphrase);
+  return mainAccount;
+}
+async function createKeyringPair(opts) {
+  const { filePath, passphrase, cryptoType } = opts;
+  const type = cryptoType ?? "sr25519";
+  const seed = mnemonicGenerate();
+  const keyring = new Keyring().createFromUri(seed, { type });
+  if (filePath) {
+    const json = keyring.toJson(passphrase);
+    await writeFile(filePath, JSON.stringify(json, null, 2));
+  }
+  return keyring;
+}
+
+// src/clis/index.ts
+import { Command as Command6, Option as Option2 } from "@commander-js/extra-typings";
+
+// src/clis/accountCli.ts
+import { Command } from "@commander-js/extra-typings";
+import { printTable as printTable3 } from "console-table-printer";
+import { cryptoWaitReady } from "@polkadot/util-crypto";
+import { writeFileSync } from "node:fs";
+import * as process3 from "node:process";
+
+// src/clis/index.ts
+import { configDotenv } from "dotenv";
+import Path from "node:path";
+
+// src/clis/vaultCli.ts
+import { Command as Command2 } from "@commander-js/extra-typings";
+import BigNumber3 from "bignumber.js";
+
+// src/clis/miningCli.ts
+import { Command as Command3 } from "@commander-js/extra-typings";
+import { printTable as printTable4 } from "console-table-printer";
+
+// src/clis/liquidityCli.ts
+import { Command as Command4 } from "@commander-js/extra-typings";
+
+// src/clis/bitcoinCli.ts
+import { Command as Command5 } from "@commander-js/extra-typings";
+
+// src/index.ts
+export * from "@polkadot/types";
+export * from "@polkadot/types/interfaces";
+async function waitForLoad() {
+  await cryptoWaitReady2();
+}
+async function getClient(host) {
+  let provider;
+  if (host.startsWith("http:")) {
+    provider = new HttpProvider(host);
+  } else {
+    provider = new WsProvider(host);
+  }
+  return await ApiPromise.create({ provider, noInitWarn: true });
+}
+export {
+  AccountMiners,
+  AccountRegistry,
+  Accountset,
+  BidPool,
+  BitcoinLocks,
+  BlockWatch,
+  CohortBidder,
+  JsonExt,
+  Keyring,
+  MiningBids,
+  MiningRotations,
+  TxSubmitter,
+  Vault,
+  VaultMonitor,
+  WageProtector,
+  checkForExtrinsicSuccess,
+  convertFixedU128ToBigNumber,
+  convertPermillToBigNumber,
+  createKeyringPair,
+  decodeAddress,
+  dispatchErrorToString,
+  eventDataToJson,
+  filterUndefined,
+  formatArgons,
+  formatPercent,
+  getAuthorFromHeader,
+  getClient,
+  getTickFromHeader,
+  gettersToObject,
+  keyringFromCli,
+  keyringFromFile,
+  keyringFromSuri,
+  mnemonicGenerate,
+  waitForLoad
+};
+//# sourceMappingURL=index.js.map