@argonprotocol/mainchain 1.1.0 → 1.2.0

package/lib/chunk-CHGCEO2U.cjs

@@ -0,0 +1,2567 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;// src/interfaces/augment-api-consts.ts
+require('@polkadot/api-base/types/consts');
+
+// src/interfaces/augment-api-errors.ts
+require('@polkadot/api-base/types/errors');
+
+// src/interfaces/augment-api-events.ts
+require('@polkadot/api-base/types/events');
+
+// src/interfaces/augment-api-query.ts
+require('@polkadot/api-base/types/storage');
+
+// src/interfaces/augment-api-tx.ts
+require('@polkadot/api-base/types/submittable');
+
+// src/interfaces/augment-api-rpc.ts
+require('@polkadot/rpc-core/types/jsonrpc');
+
+// src/interfaces/augment-api-runtime.ts
+require('@polkadot/api-base/types/calls');
+
+// src/interfaces/augment-types.ts
+require('@polkadot/types/types/registry');
+
+// src/index.ts
+var _api = require('@polkadot/api');
+
+
+
+
+var _utilcrypto = require('@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/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 + (_nullishCoalesce(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 = class {
+  constructor(client, shouldLog = false) {;_class.prototype.__init.call(this);
+    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(() => {
+    });
+  }
+  
+  
+  
+  __init() {this.events = []}
+  /**
+   * The index of the batch that was interrupted, if any.
+   */
+  
+  
+  /**
+   * The final fee paid for the transaction, including the fee tip.
+   */
+  
+  /**
+   * The fee tip paid for the transaction.
+   */
+  
+  
+  
+  
+  
+  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);
+  }
+}, _class);
+
+// src/utils.ts
+var _bignumberjs = require('bignumber.js'); var BN = _interopRequireWildcard(_bignumberjs); var BN2 = _interopRequireWildcard(_bignumberjs);
+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 = BN.default.call(void 0, 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 (0, BN.default)(10).pow(new (0, BN.default)(18));
+  const rawValue = new (0, BN.default)(fixedU128.toString());
+  return rawValue.div(decimalFactor);
+}
+function convertPermillToBigNumber(permill) {
+  const decimalFactor = new (0, BN.default)(1e6);
+  const rawValue = new (0, BN.default)(permill.toString());
+  return rawValue.div(decimalFactor);
+}
+function eventDataToJson(event) {
+  const obj = {};
+  event.data.forEach((data, index) => {
+    const name = _optionalChain([event, 'access', _2 => _2.data, 'access', _3 => _3.names, 'optionalAccess', _4 => _4[index]]);
+    obj[_nullishCoalesce(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} ${_nullishCoalesce(this.details, () => ( ""))} (Batch interrupted at index ${this.batchInterruptedIndex})`;
+    }
+    return `${this.errorCode} ${_nullishCoalesce(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;
+    });
+  }
+};
+function createNanoEvents() {
+  return new TypedEmitter();
+}
+var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init2.call(this); }
+  __init2() {this.events = {}}
+  emit(event, ...args) {
+    for (const cb of this.events[event] || []) {
+      cb(...args);
+    }
+  }
+  on(event, cb) {
+    (this.events[event] ||= []).push(cb);
+    return () => {
+      this.events[event] = _optionalChain([this, 'access', _5 => _5.events, 'access', _6 => _6[event], 'optionalAccess', _7 => _7.filter, 'call', _8 => _8((i) => cb !== i)]);
+    };
+  }
+}, _class2);
+
+// src/AccountRegistry.ts
+var AccountRegistry = (_class3 = class _AccountRegistry {
+  __init3() {this.namedAccounts = /* @__PURE__ */ new Map()}
+  __init4() {this.me = "me"}
+  constructor(name) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);
+    if (name) {
+      this.me = name;
+    }
+  }
+  getName(address) {
+    return this.namedAccounts.get(address);
+  }
+  register(address, name) {
+    this.namedAccounts.set(address, name);
+  }
+  static __initStatic() {this.factory = (name) => new _AccountRegistry(name)}
+}, _class3.__initStatic(), _class3);
+
+// src/Accountset.ts
+var _process = require('process'); var process2 = _interopRequireWildcard(_process);
+
+// src/BlockWatch.ts
+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 = (_class4 = class {
+  constructor(mainchain, options = {}) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);
+    this.mainchain = mainchain;
+    this.options = options;
+    this.options.shouldLog ??= true;
+    this.options.finalizedBlocks ??= false;
+  }
+  __init5() {this.events = createNanoEvents()}
+  __init6() {this.locksById = {}}
+  
+  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.locksById[utxoId.toNumber()] = {
+            vaultId: vaultId.toNumber(),
+            lockPrice: 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,
+            lockPrice: details.lockPrice
+          });
+          data.lockPrice = formatArgons(details.lockPrice);
+          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})`,
+                _optionalChain([ext, 'access', _9 => _9.toHuman, 'call', _10 => _10(), 'optionalAccess', _11 => _11.method, 'optionalAccess', _12 => _12.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);
+    if (!this.locksById[utxoId]) {
+      const lock = await api.query.bitcoinLocks.locksByUtxoId(utxoId);
+      this.locksById[utxoId] = {
+        vaultId: lock.value.vaultId.toNumber(),
+        lockPrice: lock.value.lockPrice.toBigInt()
+      };
+    }
+    return this.locksById[utxoId];
+  }
+}, _class4);
+
+// src/FrameCalculator.ts
+var FrameCalculator = class {
+  
+  
+  async getForTick(client, tick) {
+    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
+    const ticksSinceMiningStart = tick - biddingStartTick;
+    return Math.floor(ticksSinceMiningStart / ticksBetweenFrames);
+  }
+  async getTickRangeForFrame(client, frameId) {
+    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
+    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
+    const endingTick = startingTick + ticksBetweenFrames - 1;
+    return [startingTick, endingTick];
+  }
+  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);
+  }
+  async getConfig(client) {
+    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 config = this.miningConfig;
+    const genesisTick = this.genesisTick;
+    return {
+      ticksBetweenFrames: config.ticksBetweenSlots,
+      slotBiddingStartAfterTicks: config.slotBiddingStartAfterTicks,
+      genesisTick,
+      biddingStartTick: genesisTick + config.slotBiddingStartAfterTicks
+    };
+  }
+};
+
+// src/AccountMiners.ts
+var AccountMiners = (_class5 = class _AccountMiners {
+  constructor(accountset, registeredMiners, options = { shouldLog: false }) {;_class5.prototype.__init7.call(this);_class5.prototype.__init8.call(this);
+    this.accountset = accountset;
+    this.options = options;
+    this.frameCalculator = new FrameCalculator();
+    for (const seat of registeredMiners) {
+      this.trackedAccountsByAddress[seat.address] = {
+        startingFrameId: seat.startingFrameId,
+        subaccountIndex: seat.subaccountIndex
+      };
+    }
+  }
+  __init7() {this.events = createNanoEvents()}
+  
+  __init8() {this.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 currentFrameId = await this.frameCalculator.getForTick(client, tick);
+    let newMiners;
+    const dataByCohort = { duringFrameId: currentFrameId };
+    for (const event of events) {
+      if (client.events.miningSlot.NewMiners.is(event)) {
+        newMiners = {
+          frameId: event.data.frameId.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.startingFrameId] ??= {
+              argonsMinted: 0n,
+              argonsMined: 0n,
+              argonotsMined: 0n
+            };
+            dataByCohort[entry.startingFrameId].argonotsMined += ownership.toBigInt();
+            dataByCohort[entry.startingFrameId].argonsMined += argons.toBigInt();
+            this.events.emit("mined", header, {
+              author,
+              argons: argons.toBigInt(),
+              argonots: ownership.toBigInt(),
+              forCohortWithStartingFrameId: entry.startingFrameId,
+              duringFrameId: currentFrameId
+            });
+          }
+        }
+      }
+      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 { startingFrameId } = info;
+            dataByCohort[startingFrameId] ??= {
+              argonsMinted: 0n,
+              argonsMined: 0n,
+              argonotsMined: 0n
+            };
+            dataByCohort[startingFrameId].argonsMinted += amountPerMiner;
+            this.events.emit("minted", header, {
+              accountId: address,
+              argons: amountPerMiner,
+              forCohortWithStartingFrameId: startingFrameId,
+              duringFrameId: currentFrameId
+            });
+          }
+        }
+      }
+    }
+    if (newMiners) {
+      this.newCohortMiners(newMiners.frameId, newMiners.addresses);
+    }
+    return dataByCohort;
+  }
+  newCohortMiners(frameId, addresses) {
+    for (const [address, info] of Object.entries(
+      this.trackedAccountsByAddress
+    )) {
+      if (info.startingFrameId === frameId - 10) {
+        delete this.trackedAccountsByAddress[address];
+      }
+    }
+    for (const address of addresses) {
+      const entry = this.accountset.subAccountsByAddress[address];
+      if (entry) {
+        this.trackedAccountsByAddress[address] = {
+          startingFrameId: frameId,
+          subaccountIndex: entry.index
+        };
+      }
+    }
+  }
+  static async loadAt(accountset, options = {}) {
+    const seats = await accountset.miningSeats(options.blockHash);
+    const registered = seats.filter((x) => x.seat !== void 0);
+    return new _AccountMiners(accountset, registered, {
+      shouldLog: _nullishCoalesce(options.shouldLog, () => ( false))
+    });
+  }
+}, _class5);
+
+// src/Accountset.ts
+var Accountset = (_class6 = class {
+  
+  __init9() {this.isProxy = false}
+  
+  __init10() {this.subAccountsByAddress = {}}
+  
+  
+  get addresses() {
+    return [this.seedAddress, ...Object.keys(this.subAccountsByAddress)];
+  }
+  get namedAccounts() {
+    return this.accountRegistry.namedAccounts;
+  }
+  
+  constructor(options) {;_class6.prototype.__init9.call(this);_class6.prototype.__init10.call(this);
+    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 = _nullishCoalesce(options.accountRegistry, () => ( AccountRegistry.factory(options.name)));
+    this.client = options.client;
+    const defaultRange = _nullishCoalesce(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: _nullishCoalesce(_optionalChain([this, 'access', _13 => _13.subAccountsByAddress, 'access', _14 => _14[address], 'optionalAccess', _15 => _15.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: _nullishCoalesce(_optionalChain([this, 'access', _16 => _16.subAccountsByAddress, 'access', _17 => _17[address], 'optionalAccess', _18 => _18.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 frameIds = [
+      ...new Set(
+        rawIndices.map((x) => x.isNone ? void 0 : x.value[0].toNumber()).filter((x) => x !== void 0)
+      )
+    ];
+    const bidAmountsByFrame = {};
+    if (frameIds.length) {
+      console.log("Looking up cohorts for frames", frameIds);
+      const cohorts = await api.query.miningSlot.minersByCohort.multi(frameIds);
+      for (let i = 0; i < frameIds.length; i++) {
+        const cohort = cohorts[i];
+        const frameId = frameIds[i];
+        bidAmountsByFrame[frameId] = cohort.map((x) => x.bid.toBigInt());
+      }
+    }
+    const addressToMiningIndex = {};
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      if (rawIndices[i].isNone) continue;
+      const [frameIdRaw, indexRaw] = rawIndices[i].value;
+      const frameId = frameIdRaw.toNumber();
+      const index = indexRaw.toNumber();
+      const bidAmount = _optionalChain([bidAmountsByFrame, 'access', _19 => _19[frameId], 'optionalAccess', _20 => _20[index]]);
+      addressToMiningIndex[address] = {
+        frameId,
+        index,
+        bidAmount: _nullishCoalesce(bidAmount, () => ( 0n))
+      };
+    }
+    const nextFrameId = await api.query.miningSlot.nextFrameId();
+    return addresses.map((address) => {
+      const cohort = addressToMiningIndex[address];
+      let isLastDay = false;
+      if (cohort !== void 0) {
+        isLastDay = nextFrameId.toNumber() - cohort.frameId === 10;
+      }
+      return {
+        address,
+        seat: cohort,
+        isLastDay,
+        subaccountIndex: _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.subAccountsByAddress, 'access', _22 => _22[address], 'optionalAccess', _23 => _23.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.bidsForNextSlotCohort();
+    return miners.map((miner) => {
+      const bid = nextCohort.find((x) => x.accountId.toHuman() === miner.address);
+      return {
+        ...miner,
+        hasWinningBid: !!bid,
+        bidAmount: _nullishCoalesce(_nullishCoalesce(_optionalChain([bid, 'optionalAccess', _24 => _24.bid, 'access', _25 => _25.toBigInt, 'call', _26 => _26()]), () => ( _optionalChain([miner, 'access', _27 => _27.seat, 'optionalAccess', _28 => _28.bidAmount]))), () => ( 0n))
+      };
+    });
+  }
+  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.bidsForNextSlotCohort();
+    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: _optionalChain([entry, 'optionalAccess', _29 => _29.index]),
+        bidAmount: _optionalChain([entry, 'optionalAccess', _30 => _30.bid, 'optionalAccess', _31 => _31.toBigInt, 'call', _32 => _32()]),
+        index: _nullishCoalesce(_optionalChain([this, 'access', _33 => _33.subAccountsByAddress, 'access', _34 => _34[address], 'optionalAccess', _35 => _35.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(
+          _nullishCoalesce(_optionalChain([argons, 'access', _36 => _36.find, 'call', _37 => _37((x) => x.address === this.seedAddress), 'optionalAccess', _38 => _38.amount]), () => ( 0n))
+        ),
+        argonots: formatArgons(
+          _nullishCoalesce(_optionalChain([argonots, 'access', _39 => _39.find, 'call', _40 => _40((x) => x.address === this.seedAddress), 'optionalAccess', _41 => _41.amount]), () => ( 0n))
+        )
+      }
+    ];
+    for (const [address, { index }] of Object.entries(
+      this.subAccountsByAddress
+    )) {
+      const argonAmount = _nullishCoalesce(_optionalChain([argons, 'access', _42 => _42.find, 'call', _43 => _43((x) => x.address === address), 'optionalAccess', _44 => _44.amount]), () => ( 0n));
+      const argonotAmount = _nullishCoalesce(_optionalChain([argonots, 'access', _45 => _45.find, 'call', _46 => _46((x) => x.address === address), 'optionalAccess', _47 => _47.amount]), () => ( 0n));
+      const bid = bids.find((x) => x.address === address);
+      const seat = _optionalChain([seats, 'access', _48 => _48.find, 'call', _49 => _49((x) => x.address === address), 'optionalAccess', _50 => _50.seat]);
+      const entry = {
+        index: ` //${index}`,
+        address,
+        argons: formatArgons(argonAmount),
+        argonots: formatArgons(argonotAmount),
+        seat,
+        bidPlace: _optionalChain([bid, 'optionalAccess', _51 => _51.bidPlace]),
+        bidAmount: _nullishCoalesce(_optionalChain([bid, 'optionalAccess', _52 => _52.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 = _nullishCoalesce(keysVersion, () => ( 0));
+    if (process2.env.KEYS_VERSION) {
+      version = _nullishCoalesce(parseInt(process2.env.KEYS_VERSION), () => ( 0));
+    }
+    const seedMnemonic = _nullishCoalesce(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 (0, _api.Keyring)().createFromUri(blockSealKey, {
+      type: "ed25519"
+    });
+    const grandpaAccount = new (0, _api.Keyring)().createFromUri(granKey, {
+      type: "ed25519"
+    });
+    return {
+      seal: {
+        privateKey: blockSealKey,
+        publicKey: `0x${Buffer.from(blockSealAccount.publicKey).toString("hex")}`,
+        rawPublicKey: blockSealAccount.publicKey
+      },
+      gran: {
+        privateKey: granKey,
+        publicKey: `0x${Buffer.from(grandpaAccount.publicKey).toString("hex")}`,
+        rawPublicKey: grandpaAccount.publicKey
+      }
+    };
+  }
+  async tx(tx) {
+    const client = await this.client;
+    return new TxSubmitter(client, tx, this.txSubmitterPair);
+  }
+  /**
+   * Create but don't submit a mining bid transaction.
+   * @param options
+   */
+  async createMiningBidTx(options) {
+    const client = await this.client;
+    const { bidAmount, subaccounts } = options;
+    const batch = client.tx.utility.batch(
+      subaccounts.map((x) => {
+        const keys = this.keys();
+        return client.tx.miningSlot.bid(
+          bidAmount,
+          {
+            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(_nullishCoalesce(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;
+  }
+}, _class6);
+function getDefaultSubaccountRange() {
+  try {
+    return parseSubaccountRange(_nullishCoalesce(process2.env.SUBACCOUNT_RANGE, () => ( "0-9")));
+  } catch (e2) {
+    console.error(
+      "Failed to parse SUBACCOUNT_RANGE environment variable. Defaulting to 0-9. Please check the format of the SUBACCOUNT_RANGE variable."
+    );
+    return Array.from({ length: 10 }, (_, i) => i);
+  }
+}
+function parseSubaccountRange(range) {
+  if (!range) {
+    return void 0;
+  }
+  const indices = [];
+  for (const entry of range.split(",")) {
+    if (entry.includes("-")) {
+      const [start, end] = entry.split("-").map((x) => parseInt(x, 10));
+      for (let i = start; i <= end; i++) {
+        indices.push(i);
+      }
+      continue;
+    }
+    const record = parseInt(entry.trim(), 10);
+    if (Number.isNaN(record) || !Number.isInteger(record)) {
+      throw new Error(`Invalid range entry: ${entry}`);
+    }
+    if (Number.isInteger(record)) {
+      indices.push(record);
+    }
+  }
+  return indices;
+}
+
+// src/MiningBids.ts
+var _consoletableprinter = require('console-table-printer');
+var MiningBids = (_class7 = class {
+  constructor(client, shouldLog = true) {;_class7.prototype.__init11.call(this);
+    this.client = client;
+    this.shouldLog = shouldLog;
+  }
+  __init11() {this.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 openCohortStartingFrameId = 0;
+    const unsubscribe = await client.queryMulti(
+      [
+        client.query.miningSlot.isNextSlotBiddingOpen,
+        client.query.miningSlot.nextFrameId
+      ],
+      async ([isBiddingOpen, rawNextCohortStartingFrameId]) => {
+        const nextFrameId = rawNextCohortStartingFrameId.toNumber();
+        if (isBiddingOpen.isTrue) {
+          if (openCohortStartingFrameId !== 0) {
+            await _optionalChain([onBiddingEnd, 'optionalCall', _53 => _53(openCohortStartingFrameId)]);
+          }
+          openCohortStartingFrameId = nextFrameId;
+          await _optionalChain([onBiddingStart, 'optionalCall', _54 => _54(nextFrameId)]);
+        } else {
+          await _optionalChain([onBiddingEnd, 'optionalCall', _55 => _55(nextFrameId)]);
+          openCohortStartingFrameId = 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.bidsForNextSlotCohort(
+      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.bidsForNextSlotCohort();
+    this.nextCohort = await Promise.all(
+      nextCohort.map((x) => this.toBid(accountNames, x))
+    );
+  }
+  async toBid(accountNames, bid) {
+    return {
+      accountId: bid.accountId.toString(),
+      isOurs: _nullishCoalesce(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:");
+      _consoletableprinter.printTable.call(void 0, bids);
+    }
+  }
+}, _class7);
+
+// src/Vault.ts
+
+var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
+var Vault = (_class8 = class {
+  
+  
+  
+  
+  __init12() {this.argonsScheduledForRelease = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  
+  
+  
+  constructor(id, vault, tickDuration) {;_class8.prototype.__init12.call(this);
+    this.securitization = vault.securitization.toBigInt();
+    this.securitizationRatio = convertFixedU128ToBigNumber(
+      vault.securitizationRatio.toBigInt()
+    );
+    this.argonsLocked = vault.argonsLocked.toBigInt();
+    this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
+    if (vault.argonsScheduledForRelease.size > 0) {
+      this.argonsScheduledForRelease.clear();
+      for (const [tick, amount] of vault.argonsScheduledForRelease.entries()) {
+        this.argonsScheduledForRelease.set(tick.toNumber(), amount.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();
+    const reLockable = this.getRelockCapacity();
+    return this.securitization - recoverySecuritization - this.argonsLocked + reLockable;
+  }
+  getRelockCapacity() {
+    return [...this.argonsScheduledForRelease.values()].reduce(
+      (acc, val) => acc + val,
+      0n
+    );
+  }
+  recoverySecuritization() {
+    const reserved = new (0, BN.default)(1).div(this.securitizationRatio);
+    return this.securitization - BigInt(
+      reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2)
+    );
+  }
+  minimumSecuritization() {
+    return BigInt(
+      this.securitizationRatio.multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BN.default.ROUND_CEIL).toString()
+    );
+  }
+  activatedSecuritization() {
+    const activated = this.argonsLocked - this.argonsPendingActivation;
+    let maxRatio = this.securitizationRatio;
+    if (this.securitizationRatio.toNumber() > 2) {
+      maxRatio = BN.default.call(void 0, 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(BN.default.ROUND_CEIL);
+    return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
+  }
+}, _class8);
+
+// src/VaultMonitor.ts
+
+var VaultMonitor = (_class9 = class {
+  constructor(accountset, alerts = {}, options = {}) {;_class9.prototype.__init13.call(this);_class9.prototype.__init14.call(this);_class9.prototype.__init15.call(this);_class9.prototype.__init16.call(this);_class9.prototype.__init17.call(this);_class9.prototype.__init18.call(this);
+    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);
+    });
+  }
+  __init13() {this.events = createNanoEvents()}
+  __init14() {this.vaultsById = {}}
+  
+  
+  __init15() {this.activatedCapitalByVault = {}}
+  
+  
+  __init16() {this.tickDuration = 0}
+  __init17() {this.vaultOnlyWatchMode = false}
+  __init18() {this.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.capitalRaising((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.argonsPendingActivation)} 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:");
+      _consoletableprinter.printTable.call(void 0, 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 = _nullishCoalesce(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;
+  }
+}, _class9);
+
+// src/CohortBidderHistory.ts
+var CohortBidderHistory = (_class10 = class _CohortBidderHistory {
+  constructor(cohortStartingFrameId, subaccounts) {;_class10.prototype.__init19.call(this);_class10.prototype.__init20.call(this);_class10.prototype.__init21.call(this);_class10.prototype.__init22.call(this);_class10.prototype.__init23.call(this);
+    this.cohortStartingFrameId = cohortStartingFrameId;
+    this.subaccounts = subaccounts;
+    this.maxSeatsInPlay = this.subaccounts.length;
+    this.subaccounts.forEach((x) => {
+      this.myAddresses.add(x.address);
+    });
+  }
+  __init19() {this.bidHistory = []}
+  __init20() {this.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
+  }}
+  __init21() {this.lastBids = []}
+  __init22() {this.myAddresses = /* @__PURE__ */ new Set()}
+  __init23() {this.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 = {
+      cohortStartingFrameId: this.cohortStartingFrameId,
+      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
+      );
+    }
+    if (historyEntry.myBidsPlaced) {
+      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 };
+  }
+}, _class10);
+
+// src/CohortBidder.ts
+var CohortBidder = (_class11 = class {
+  constructor(accountset, cohortStartingFrameId, subaccounts, options) {;_class11.prototype.__init24.call(this);_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);_class11.prototype.__init27.call(this);
+    this.accountset = accountset;
+    this.cohortStartingFrameId = cohortStartingFrameId;
+    this.subaccounts = subaccounts;
+    this.options = options;
+    this.history = new CohortBidderHistory(cohortStartingFrameId, 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;
+  }
+  
+  
+  
+  __init24() {this.isStopped = false}
+  __init25() {this.needsRebid = false}
+  __init26() {this.lastBidTime = 0}
+  
+  
+  __init27() {this.myAddresses = /* @__PURE__ */ new Set()}
+  async stop() {
+    if (this.isStopped) return this.stats;
+    this.isStopped = true;
+    console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
+    clearTimeout(this.retryTimeout);
+    if (this.unsubscribe) {
+      this.unsubscribe();
+    }
+    const client = await this.client;
+    const [nextFrameId, isBiddingOpen] = await client.queryMulti([
+      client.query.miningSlot.nextFrameId,
+      client.query.miningSlot.isNextSlotBiddingOpen
+    ]);
+    if (nextFrameId.toNumber() === this.cohortStartingFrameId && 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 cohortStartingFrameId = await api2.query.miningSlot.nextFrameId();
+      if (cohortStartingFrameId.toNumber() === this.cohortStartingFrameId) {
+        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 bids = await api.query.miningSlot.bidsForNextSlotCohort();
+    this.history.trackChange(bids, header.number.toNumber(), tick, true);
+    console.log("Bidder stopped", {
+      cohortStartingFrameId: this.cohortStartingFrameId,
+      blockNumber: header.number.toNumber(),
+      tick,
+      bids: bids.map((x) => ({
+        address: x.accountId.toHuman(),
+        bid: x.bid.toBigInt()
+      }))
+    });
+    return this.stats;
+  }
+  async start() {
+    console.log(`Starting cohort ${this.cohortStartingFrameId} 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.bidsForNextSlotCohort,
+        client.query.miningSlot.nextFrameId
+      ],
+      async ([bids, nextFrameId]) => {
+        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
+          await this.checkWinningBids(bids);
+        }
+      }
+    );
+  }
+  async checkWinningBids(bids) {
+    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 (_optionalChain([this, 'access', _56 => _56.bidHistory, 'access', _57 => _57[0], 'optionalAccess', _58 => _58.blockNumber]) >= blockNumber) {
+      return;
+    }
+    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
+    const historyEntry = this.history.trackChange(bids, 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.cohortStartingFrameId,
+      this.subaccounts.map((x) => x.index)
+    );
+    const winningBids = historyEntry.winningSeats;
+    this.needsRebid = winningBids < this.subaccounts.length;
+    if (!this.needsRebid) return;
+    const winningAddresses = new Set(bids.map((x) => x.accountId.toHuman()));
+    let lowestBid = -this.options.bidIncrement;
+    if (bids.length) {
+      for (let i = bids.length - 1; i >= 0; i--) {
+        if (!this.myAddresses.has(bids[i].accountId.toHuman())) {
+          lowestBid = bids.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
+    });
+    let availableBalanceForBids = await api.query.system.account(this.accountset.txSubmitterPair.address).then((x) => x.data.free.toBigInt());
+    for (const bid of bids) {
+      if (this.myAddresses.has(bid.accountId.toHuman())) {
+        availableBalanceForBids += bid.bid.toBigInt();
+      }
+    }
+    const tip = _nullishCoalesce(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.cohortStartingFrameId} 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
+      });
+      const tip = _nullishCoalesce(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 = _nullishCoalesce(txResult.batchInterruptedIndex, () => ( subaccounts.length));
+      this.history.onBidResult(historyEntry, {
+        blockNumber,
+        successfulBids,
+        bidPerSeat,
+        txFeePlusTip: _nullishCoalesce(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.cohortStartingFrameId}:`,
+        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 bids = await client.query.miningSlot.bidsForNextSlotCohort();
+    await this.checkWinningBids(bids);
+  }
+}, _class11);
+
+// src/BidPool.ts
+
+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 = (_class12 = class {
+  constructor(client, keypair, accountRegistry = AccountRegistry.factory()) {;_class12.prototype.__init28.call(this);_class12.prototype.__init29.call(this);_class12.prototype.__init30.call(this);_class12.prototype.__init31.call(this);_class12.prototype.__init32.call(this);_class12.prototype.__init33.call(this);
+    this.client = client;
+    this.keypair = keypair;
+    this.accountRegistry = accountRegistry;
+    this.blockWatch = new BlockWatch(client, { shouldLog: false });
+  }
+  __init28() {this.bidPoolAmount = 0n}
+  __init29() {this.nextFrameId = 1}
+  __init30() {this.poolVaultCapitalByFrame = {}}
+  __init31() {this.vaultSecuritization = []}
+  
+  
+  __init32() {this.vaultsById = {}}
+  
+  
+  __init33() {this.FrameSubscriptions = {}}
+  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.nextFrameId = (await api.query.miningSlot.nextFrameId()).toNumber();
+    const contributors = await api.query.liquidityPools.vaultPoolsByFrame.entries();
+    for (const [frameId, funds] of contributors) {
+      const FrameIdNumber = frameId.args[0].toNumber();
+      this.loadFrameData(FrameIdNumber, funds);
+    }
+    for (const entrant of await api.query.liquidityPools.capitalActive()) {
+      this.setVaultFrameData(
+        entrant.frameId.toNumber(),
+        entrant.vaultId.toNumber(),
+        {
+          activatedCapital: entrant.activatedCapital.toBigInt()
+        }
+      );
+    }
+    for (const entrant of await api.query.liquidityPools.capitalRaising()) {
+      this.setVaultFrameData(
+        entrant.frameId.toNumber(),
+        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 { frameId: rawFrameId } = event.data;
+        this.lastDistributedFrameId = rawFrameId.toNumber();
+        this.bidPoolAmount = await this.getBidPool();
+        _optionalChain([this, 'access', _59 => _59.FrameSubscriptions, 'access', _60 => _60[rawFrameId.toNumber()], 'optionalCall', _61 => _61()]);
+        const entrant = await api.query.liquidityPools.vaultPoolsByFrame(rawFrameId);
+        this.loadFrameData(rawFrameId.toNumber(), entrant);
+        this.printDebounce();
+      }
+      if (api.events.liquidityPools.NextBidPoolCapitalLocked.is(event)) {
+        const { frameId } = event.data;
+        for (let inc = 0; inc < 2; inc++) {
+          const id = frameId.toNumber() + inc;
+          if (!this.FrameSubscriptions[id]) {
+            this.FrameSubscriptions[id] = await api.query.liquidityPools.vaultPoolsByFrame(
+              id,
+              async (entrant) => {
+                this.loadFrameData(id, entrant);
+                this.printDebounce();
+              }
+            );
+          }
+        }
+      }
+    });
+    const unsubscribe = await api.queryMulti(
+      [
+        api.query.miningSlot.bidsForNextSlotCohort,
+        api.query.miningSlot.nextFrameId,
+        api.query.liquidityPools.capitalActive,
+        api.query.liquidityPools.capitalRaising
+      ],
+      async ([
+        _bids,
+        nextFrameId,
+        openVaultBidPoolCapital,
+        nextPoolCapital
+      ]) => {
+        this.bidPoolAmount = await this.getBidPool();
+        this.nextFrameId = nextFrameId.toNumber();
+        for (const entrant of [
+          ...openVaultBidPoolCapital,
+          ...nextPoolCapital
+        ]) {
+          this.setVaultFrameData(
+            entrant.frameId.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: _optionalChain([options, 'optionalAccess', _62 => _62.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: _optionalChain([options, 'optionalAccess', _63 => _63.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 _nullishCoalesce(this.accountRegistry.getName(vault.operatorAccountId), () => ( vault.operatorAccountId));
+  }
+  print() {
+    console.clear();
+    const lastDistributedFrameId = this.lastDistributedFrameId;
+    const distributedFrame = _nullishCoalesce(this.poolVaultCapitalByFrame[_nullishCoalesce(this.lastDistributedFrameId, () => ( -1))], () => ( {}));
+    if (Object.keys(distributedFrame).length > 0) {
+      console.log(`
+
+Distributed (Frame ${lastDistributedFrameId})`);
+      const rows = [];
+      let maxWidth2 = 0;
+      for (const [key, entry] of Object.entries(distributedFrame)) {
+        const { table, width } = this.createBondCapitalTable(
+          _nullishCoalesce(entry.earnings, () => ( 0n)),
+          _nullishCoalesce(entry.contributors, () => ( [])),
+          `Earnings (shared = ${formatPercent(entry.vaultSharingPercent)})`
+        );
+        if (width > maxWidth2) {
+          maxWidth2 = width;
+        }
+        rows.push({
+          Vault: key,
+          Who: this.getOperatorName(Number(key)),
+          Balances: table
+        });
+      }
+      new (0, _consoletableprinter.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)} (Frame ${this.nextFrameId})`
+    );
+    const Frame = this.poolVaultCapitalByFrame[this.nextFrameId];
+    if (Object.keys(_nullishCoalesce(Frame, () => ( {}))).length > 0) {
+      const rows = [];
+      let maxWidth2 = 0;
+      for (const [key, entry] of Object.entries(Frame)) {
+        const { table, width } = this.createBondCapitalTable(
+          entry.activatedCapital,
+          _nullishCoalesce(entry.contributors, () => ( []))
+        );
+        if (width > maxWidth2) {
+          maxWidth2 = width;
+        }
+        rows.push({
+          Vault: key,
+          Who: this.getOperatorName(Number(key)),
+          "Pool Capital": table
+        });
+      }
+      new (0, _consoletableprinter.Table)({
+        columns: [
+          { name: "Vault", alignment: "left" },
+          { name: "Who", alignment: "left" },
+          { name: "Pool Capital", alignment: "left", minLen: maxWidth2 }
+        ],
+        rows
+      }).printTable();
+    }
+    const raisingFunds = _nullishCoalesce(this.poolVaultCapitalByFrame[this.nextFrameId + 1], () => ( []));
+    let maxWidth = 0;
+    const nextCapital = [];
+    for (const x of this.vaultSecuritization) {
+      const entry = _nullishCoalesce(raisingFunds[x.vaultId], () => ( {}));
+      const { table, width } = this.createBondCapitalTable(
+        x.activatedSecuritization,
+        _nullishCoalesce(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(`
+
+Raising Funds (Frame ${this.nextFrameId + 1}):`);
+      new (0, _consoletableprinter.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();
+    }
+  }
+  setVaultFrameData(frameId, vaultId, data) {
+    this.poolVaultCapitalByFrame ??= {};
+    this.poolVaultCapitalByFrame[frameId] ??= {};
+    this.poolVaultCapitalByFrame[frameId][vaultId] ??= {
+      activatedCapital: _nullishCoalesce(_nullishCoalesce(data.activatedCapital, () => ( _optionalChain([data, 'access', _64 => _64.contributors, 'optionalAccess', _65 => _65.reduce, 'call', _66 => _66((a, b) => a + b.amount, 0n)]))), () => ( 0n))
+    };
+    Object.assign(
+      this.poolVaultCapitalByFrame[frameId][vaultId],
+      filterUndefined(data)
+    );
+  }
+  createBondCapitalTable(total, contributors, title = "Total") {
+    const table = new (0, _consoletableprinter.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: _nullishCoalesce(this.accountRegistry.getName(x.address), () => ( x.address)),
+        amount: formatArgons(x.amount)
+      });
+    }
+    const str = table.render();
+    const width = str.indexOf("\n");
+    return { table: str, width };
+  }
+  loadFrameData(frameId, 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 (frameId > (_nullishCoalesce(this.lastDistributedFrameId, () => ( 0)))) {
+          this.lastDistributedFrameId = frameId;
+        }
+      }
+      this.setVaultFrameData(frameId, vaultIdNumber, {
+        earnings: fund.distributedProfits.isSome ? fund.distributedProfits.unwrap().toBigInt() : void 0,
+        vaultSharingPercent: convertPermillToBigNumber(
+          fund.vaultSharingPercent.toBigInt()
+        ),
+        contributors
+      });
+    }
+  }
+}, _class12);
+
+// 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 = _nullishCoalesce(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 = _optionalChain([result, 'access', _67 => _67.events, 'access', _68 => _68.find, 'call', _69 => _69((x) => client.events.bitcoinLocks.BitcoinLockCreated.is(x)), 'optionalAccess', _70 => _70.data, 'access', _71 => _71.utxoId, 'optionalAccess', _72 => _72.toNumber, 'call', _73 => _73()]);
+          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 (0, _api.Keyring)({ type: cryptoType }).createFromUri(suri);
+}
+function createKeyringPair(opts) {
+  const { cryptoType } = opts;
+  const seed = _utilcrypto.mnemonicGenerate.call(void 0, );
+  return keyringFromSuri(seed, cryptoType);
+}
+
+// src/index.ts
+var _types = require('@polkadot/types'); _createStarExport(_types);
+var _interfaces = require('@polkadot/types/interfaces'); _createStarExport(_interfaces);
+var _types3 = require('@polkadot/types-codec/types'); _createStarExport(_types3);
+async function waitForLoad() {
+  await _utilcrypto.cryptoWaitReady.call(void 0, );
+}
+async function getClient(host) {
+  let provider;
+  if (host.startsWith("http:")) {
+    provider = new (0, _api.HttpProvider)(host);
+  } else {
+    provider = new (0, _api.WsProvider)(host);
+  }
+  return await _api.ApiPromise.create({ provider, noInitWarn: true });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.WageProtector = WageProtector; exports.TxSubmitter = TxSubmitter; exports.MICROGONS_PER_ARGON = MICROGONS_PER_ARGON; exports.formatArgons = formatArgons; exports.formatPercent = formatPercent; exports.filterUndefined = filterUndefined; exports.gettersToObject = gettersToObject; exports.convertFixedU128ToBigNumber = convertFixedU128ToBigNumber; exports.convertPermillToBigNumber = convertPermillToBigNumber; exports.eventDataToJson = eventDataToJson; exports.dispatchErrorToString = dispatchErrorToString; exports.ExtrinsicError = ExtrinsicError2; exports.dispatchErrorToExtrinsicError = dispatchErrorToExtrinsicError; exports.checkForExtrinsicSuccess = checkForExtrinsicSuccess; exports.JsonExt = JsonExt; exports.createNanoEvents = createNanoEvents; exports.TypedEmitter = TypedEmitter; exports.AccountRegistry = AccountRegistry; exports.getTickFromHeader = getTickFromHeader; exports.getAuthorFromHeader = getAuthorFromHeader; exports.BlockWatch = BlockWatch; exports.FrameCalculator = FrameCalculator; exports.AccountMiners = AccountMiners; exports.Accountset = Accountset; exports.parseSubaccountRange = parseSubaccountRange; exports.MiningBids = MiningBids; exports.Vault = Vault; exports.VaultMonitor = VaultMonitor; exports.CohortBidderHistory = CohortBidderHistory; exports.CohortBidder = CohortBidder; exports.BidPool = BidPool; exports.BitcoinLocks = BitcoinLocks; exports.keyringFromSuri = keyringFromSuri; exports.createKeyringPair = createKeyringPair; exports.Keyring = _api.Keyring; exports.decodeAddress = _utilcrypto.decodeAddress; exports.mnemonicGenerate = _utilcrypto.mnemonicGenerate; exports.waitForLoad = waitForLoad; exports.getClient = getClient;
+//# sourceMappingURL=chunk-CHGCEO2U.cjs.map