@argonprotocol/mainchain 1.1.0-rc.8 → 1.2.0

package/lib/index.js

@@ -1,2474 +1,43 @@
-// 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,
+  AccountMiners,
+  AccountRegistry,
+  Accountset,
+  BidPool,
+  BitcoinLocks,
+  BlockWatch,
+  CohortBidder,
+  CohortBidderHistory,
+  ExtrinsicError,
+  FrameCalculator,
+  JsonExt,
+  Keyring,
+  MICROGONS_PER_ARGON,
+  MiningBids,
+  TxSubmitter,
+  TypedEmitter,
+  Vault,
+  VaultMonitor,
+  WageProtector,
+  checkForExtrinsicSuccess,
+  convertFixedU128ToBigNumber,
+  convertPermillToBigNumber,
+  createKeyringPair,
+  createNanoEvents,
   decodeAddress,
-  mnemonicGenerate
-} from "@polkadot/util-crypto";
-export * from "@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
-import BigNumber, * as BN from "bignumber.js";
-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 = BigNumber(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 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;
-}
-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
-import * as process2 from "node:process";
-
-// src/BlockWatch.ts
-import { createNanoEvents } from "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 = 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
-import { createNanoEvents as createNanoEvents2 } from "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 = createNanoEvents2();
-  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 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 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
-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 { printTable as printTable2 } from "console-table-printer";
-import { createNanoEvents as createNanoEvents3 } from "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 = createNanoEvents3();
-  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/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
-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
-function keyringFromSuri(suri, cryptoType = "sr25519") {
-  return new Keyring({ type: cryptoType }).createFromUri(suri);
-}
-function createKeyringPair(opts) {
-  const { cryptoType } = opts;
-  const seed = mnemonicGenerate();
-  return keyringFromSuri(seed, cryptoType);
-}
-
-// src/index.ts
-export * from "@polkadot/types";
-export * from "@polkadot/types/interfaces";
-async function waitForLoad() {
-  await cryptoWaitReady();
-}
-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 });
-}
+  dispatchErrorToExtrinsicError,
+  dispatchErrorToString,
+  eventDataToJson,
+  filterUndefined,
+  formatArgons,
+  formatPercent,
+  getAuthorFromHeader,
+  getClient,
+  getTickFromHeader,
+  gettersToObject,
+  keyringFromSuri,
+  mnemonicGenerate,
+  waitForLoad
+} from "./chunk-RXCQYVE7.js";
 export {
   AccountMiners,
   AccountRegistry,
@@ -2477,13 +46,15 @@ export {
   BitcoinLocks,
   BlockWatch,
   CohortBidder,
-  ExtrinsicError2 as ExtrinsicError,
+  CohortBidderHistory,
+  ExtrinsicError,
+  FrameCalculator,
   JsonExt,
   Keyring,
   MICROGONS_PER_ARGON,
   MiningBids,
-  MiningRotations,
   TxSubmitter,
+  TypedEmitter,
   Vault,
   VaultMonitor,
   WageProtector,
@@ -2491,6 +62,7 @@ export {
   convertFixedU128ToBigNumber,
   convertPermillToBigNumber,
   createKeyringPair,
+  createNanoEvents,
   decodeAddress,
   dispatchErrorToExtrinsicError,
   dispatchErrorToString,