@argonprotocol/mainchain 1.3.7 → 1.3.9

package/lib/chunk-PXZPYJ4P.js

@@ -1,2982 +0,0 @@
-// src/interfaces/augment-api-consts.ts
-import "@polkadot/api-base/types/consts";
-
-// src/interfaces/augment-api-errors.ts
-import "@polkadot/api-base/types/errors";
-
-// src/interfaces/augment-api-events.ts
-import "@polkadot/api-base/types/events";
-
-// src/interfaces/augment-api-query.ts
-import "@polkadot/api-base/types/storage";
-
-// src/interfaces/augment-api-tx.ts
-import "@polkadot/api-base/types/submittable";
-
-// src/interfaces/augment-api-rpc.ts
-import "@polkadot/rpc-core/types/jsonrpc";
-
-// src/interfaces/augment-api-runtime.ts
-import "@polkadot/api-base/types/calls";
-
-// src/interfaces/augment-types.ts
-import "@polkadot/types/types/registry";
-
-// src/index.ts
-import { ApiPromise, HttpProvider, Keyring, WsProvider } from "@polkadot/api";
-import { cryptoWaitReady, decodeAddress, mnemonicGenerate } from "@polkadot/util-crypto";
-
-// src/WageProtector.ts
-var WageProtector = class _WageProtector {
-  constructor(latestCpi) {
-    this.latestCpi = latestCpi;
-  }
-  /**
-   * Converts the base wage to the current wage using the latest CPI snapshot
-   *
-   * @param baseWage The base wage to convert
-   * @returns The protected wage
-   */
-  getProtectedWage(baseWage) {
-    return baseWage * this.latestCpi.argonUsdTargetPrice / this.latestCpi.argonUsdPrice;
-  }
-  /**
-   * Subscribes to the current CPI and calls the callback function whenever the CPI changes
-   * @param client The ArgonClient to use
-   * @param callback The callback function to call when the CPI changes
-   * @returns An object with an unsubscribe function that can be called to stop the subscription
-   */
-  static async subscribe(client, callback) {
-    const unsubscribe = await client.query.priceIndex.current(async (cpi) => {
-      if (cpi.isNone) {
-        return;
-      }
-      const finalizedBlock = await client.rpc.chain.getFinalizedHead();
-      callback(
-        new _WageProtector({
-          argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
-          argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
-          finalizedBlock: new Uint8Array(finalizedBlock),
-          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/config.ts
-var config = {};
-function getEnvVar(key) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[key];
-  }
-  return void 0;
-}
-function setConfig(newConfig) {
-  config = { ...config, ...newConfig };
-}
-function getConfig() {
-  return {
-    debug: config.debug ?? getEnvVar("DEBUG") === "true",
-    keysVersion: config.keysVersion ?? (getEnvVar("KEYS_VERSION") ? parseInt(getEnvVar("KEYS_VERSION")) : void 0),
-    keySeedOrMnemonic: config.keySeedOrMnemonic ?? getEnvVar("KEYS_MNEMONIC"),
-    subaccountRange: config.subaccountRange ?? getEnvVar("SUBACCOUNT_RANGE") ?? "0-9"
-  };
-}
-
-// src/TxSubmitter.ts
-function logExtrinsicResult(result) {
-  if (getConfig().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();
-    const userBalance = availableBalance;
-    if (unavailableBalance) {
-      availableBalance -= unavailableBalance;
-    }
-    const existentialDeposit = options.includeExistentialDeposit ? this.client.consts.balances.existentialDeposit.toBigInt() : 0n;
-    const fees = await this.feeEstimate(tip);
-    const totalCharge = fees + (tip ?? 0n);
-    const canAfford = availableBalance >= totalCharge + existentialDeposit;
-    return { canAfford, availableBalance: userBalance, txFee: fees };
-  }
-  async submit(options = {}) {
-    const { logResults, waitForBlock, useLatestNonce, ...apiOptions } = options;
-    await waitForLoad();
-    const result = new TxResult(this.client, logResults);
-    result.txProgressCallback = options.txProgressCallback;
-    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 (useLatestNonce && !apiOptions.nonce) {
-      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
-    }
-    console.log("Submitting transaction from %s:", this.pair.address, ...args);
-    await this.tx.signAndSend(this.pair, apiOptions, result.onResult.bind(result));
-    if (waitForBlock) {
-      await result.inBlockPromise;
-    }
-    return result;
-  }
-};
-function formatCall(call) {
-  return `${call.section}.${call.method}`;
-}
-var TxResult = class {
-  constructor(client, shouldLog = false) {
-    this.client = client;
-    this.shouldLog = shouldLog;
-    this.inBlockPromise = new Promise((resolve, reject) => {
-      this.inBlockResolve = resolve;
-      this.inBlockReject = reject;
-    });
-    this.finalizedPromise = new Promise((resolve, reject) => {
-      this.finalizedResolve = resolve;
-      this.finalizedReject = reject;
-    });
-    this.inBlockPromise.catch(() => {
-    });
-    this.finalizedPromise.catch(() => {
-    });
-  }
-  inBlockPromise;
-  finalizedPromise;
-  status;
-  events = [];
-  /**
-   * The index of the batch that was interrupted, if any.
-   */
-  batchInterruptedIndex;
-  includedInBlock;
-  /**
-   * The final fee paid for the transaction, including the fee tip.
-   */
-  finalFee;
-  /**
-   * The fee tip paid for the transaction.
-   */
-  finalFeeTip;
-  txProgressCallback;
-  inBlockResolve;
-  inBlockReject;
-  finalizedResolve;
-  finalizedReject;
-  onResult(result) {
-    this.status = result.status;
-    if (this.shouldLog) {
-      logExtrinsicResult(result);
-    }
-    const { events, status, dispatchError, isFinalized } = result;
-    if (status.isInBlock) {
-      this.includedInBlock = new Uint8Array(status.asInBlock);
-      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(new Uint8Array(status.asInBlock));
-      }
-    }
-    if (isFinalized) {
-      this.finalizedResolve(status.asFinalized);
-    }
-    if (this.txProgressCallback) {
-      let percent = 0;
-      if (result.status.isBroadcast) {
-        percent = 50;
-      } else if (result.status.isInBlock) {
-        percent = 100;
-      }
-      this.txProgressCallback(percent, this);
-    }
-  }
-  reject(error) {
-    this.inBlockReject(error);
-    this.finalizedReject(error);
-  }
-};
-
-// src/utils.ts
-import BigNumber, * as BN from "bignumber.js";
-import { ed25519DeriveHard, keyExtractSuri, mnemonicToMiniSecret } from "@polkadot/util-crypto";
-import { u8aToHex } from "@polkadot/util";
-var { ROUND_FLOOR } = BN;
-var MICROGONS_PER_ARGON = 1e6;
-function miniSecretFromUri(uri, password) {
-  const { phrase, path } = keyExtractSuri(uri);
-  let mini = mnemonicToMiniSecret(phrase, password);
-  for (const j of path) {
-    if (!j.isHard) throw new Error("ed25519 soft derivation not supported");
-    mini = ed25519DeriveHard(mini, j.chainCode);
-  }
-  return u8aToHex(mini);
-}
-function formatArgons(microgons) {
-  if (microgons === void 0 || microgons === null) return "na";
-  const isNegative = microgons < 0;
-  let format = BigNumber(microgons.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 toFixedNumber(value, decimals) {
-  const factor = new BigNumber(10).pow(decimals);
-  const bn = new BigNumber(value);
-  const int = bn.times(factor).integerValue(BigNumber.ROUND_DOWN);
-  return BigInt(int.toFixed(0));
-}
-function convertNumberToFixedU128(value) {
-  return toFixedNumber(value, 18);
-}
-function convertFixedU128ToBigNumber(fixedU128) {
-  const decimalFactor = new BigNumber(10).pow(new BigNumber(18));
-  const rawValue = new BigNumber(fixedU128.toString());
-  return rawValue.div(decimalFactor);
-}
-function convertPermillToBigNumber(permill) {
-  const decimalFactor = new BigNumber(1e6);
-  const rawValue = new BigNumber(permill.toString());
-  return rawValue.div(decimalFactor);
-}
-function convertNumberToPermill(value) {
-  return toFixedNumber(value, 6);
-}
-function eventDataToJson(event) {
-  const obj = {};
-  event.data.forEach((data, index) => {
-    const name = event.data.names?.[index];
-    obj[name ?? `${index}`] = data.toJSON();
-  });
-  return obj;
-}
-function dispatchErrorToString(client, error) {
-  let message = error.toString();
-  if (error.isModule) {
-    const decoded = client.registry.findMetaError(error.asModule);
-    const { docs, name, section } = decoded;
-    message = `${section}.${name}: ${docs.join(" ")}`;
-  }
-  return message;
-}
-var ExtrinsicError2 = class extends Error {
-  constructor(errorCode, details, batchInterruptedIndex) {
-    super(errorCode);
-    this.errorCode = errorCode;
-    this.details = details;
-    this.batchInterruptedIndex = batchInterruptedIndex;
-  }
-  toString() {
-    if (this.batchInterruptedIndex !== void 0) {
-      return `${this.errorCode} ${this.details ?? ""} (Batch interrupted at index ${this.batchInterruptedIndex})`;
-    }
-    return `${this.errorCode} ${this.details ?? ""}`;
-  }
-};
-function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
-  if (error.isModule) {
-    const decoded = client.registry.findMetaError(error.asModule);
-    const { docs, name, section } = decoded;
-    return new ExtrinsicError2(`${section}.${name}`, docs.join(" "), batchInterruptedIndex);
-  }
-  return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
-}
-function checkForExtrinsicSuccess(events, client) {
-  return new Promise((resolve, reject) => {
-    for (const { event } of events) {
-      if (client.events.system.ExtrinsicSuccess.is(event)) {
-        resolve();
-      } else if (client.events.system.ExtrinsicFailed.is(event)) {
-        const [dispatchError] = event.data;
-        let errorInfo = dispatchError.toString();
-        if (dispatchError.isModule) {
-          const decoded = client.registry.findMetaError(dispatchError.asModule);
-          errorInfo = `${decoded.section}.${decoded.name}`;
-        }
-        reject(new Error(`${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`));
-      }
-    }
-  });
-}
-var JsonExt = class {
-  static stringify(obj, space) {
-    return JSON.stringify(
-      obj,
-      (_, v) => {
-        if (typeof v === "bigint") {
-          return `${v}n`;
-        }
-        if (v instanceof Uint8Array) {
-          return {
-            type: "Buffer",
-            data: Array.from(v)
-            // Convert Uint8Array to an array of numbers
-          };
-        }
-        return v;
-      },
-      space
-    );
-  }
-  static parse(str) {
-    return JSON.parse(str, (_, v) => {
-      if (typeof v === "string" && v.match(/^-?\d+n$/)) {
-        return BigInt(v.slice(0, -1));
-      }
-      if (typeof v === "object" && v !== null && v.type === "Buffer" && Array.isArray(v.data)) {
-        return Uint8Array.from(v.data);
-      }
-      return v;
-    });
-  }
-};
-function createNanoEvents() {
-  return new TypedEmitter();
-}
-var TypedEmitter = class {
-  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] = this.events[event]?.filter((i) => cb !== i);
-    };
-  }
-};
-
-// src/AccountRegistry.ts
-var AccountRegistry = class _AccountRegistry {
-  namedAccounts = /* @__PURE__ */ new Map();
-  me = "me";
-  constructor(name) {
-    if (name) {
-      this.me = name;
-    }
-  }
-  getName(address) {
-    return this.namedAccounts.get(address);
-  }
-  register(address, name) {
-    this.namedAccounts.set(address, name);
-  }
-  static factory = (name) => new _AccountRegistry(name);
-};
-
-// src/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 = class {
-  constructor(mainchain, options = {}) {
-    this.mainchain = mainchain;
-    this.options = options;
-    this.options.shouldLog ??= true;
-    this.options.finalizedBlocks ??= false;
-  }
-  events = createNanoEvents();
-  locksById = {};
-  unsubscribe;
-  stop() {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = void 0;
-    }
-  }
-  async start() {
-    await this.watchBlocks();
-  }
-  async watchBlocks() {
-    const client = await this.mainchain;
-    const onBlock = async (header) => {
-      try {
-        await this.processBlock(header);
-      } catch (e) {
-        console.error("Error processing block", e);
-      }
-    };
-    if (this.options.finalizedBlocks) {
-      this.unsubscribe = await client.rpc.chain.subscribeFinalizedHeads(onBlock);
-    } else {
-      this.unsubscribe = await client.rpc.chain.subscribeNewHeads(onBlock);
-    }
-  }
-  async processBlock(header) {
-    const client = await this.mainchain;
-    if (this.options.shouldLog) {
-      console.log(`-------------------------------------
-BLOCK #${header.number}, ${header.hash.toHuman()}`);
-    }
-    const blockHash = header.hash;
-    const api = await client.at(blockHash);
-    const isBlockVote = await api.query.blockSeal.isBlockFromVoteSeal();
-    if (!isBlockVote) {
-      console.warn("> Compute reactivated!");
-    }
-    const events = await api.query.system.events();
-    const reloadVaults = /* @__PURE__ */ new Set();
-    let block = void 0;
-    for (const { event, phase } of events) {
-      const data = eventDataToJson(event);
-      if (data.vaultId) {
-        const vaultId = data.vaultId;
-        reloadVaults.add(vaultId);
-      }
-      let logEvent = false;
-      if (event.section === "liquidityPools") {
-        if (client.events.liquidityPools.BidPoolDistributed.is(event)) {
-          const { bidPoolBurned, bidPoolDistributed } = event.data;
-          data.burned = formatArgons(bidPoolBurned.toBigInt());
-          data.distributed = formatArgons(bidPoolDistributed.toBigInt());
-          logEvent = true;
-        } else if (client.events.liquidityPools.NextBidPoolCapitalLocked.is(event)) {
-          const { totalActivatedCapital } = event.data;
-          data.totalActivatedCapital = formatArgons(totalActivatedCapital.toBigInt());
-          logEvent = true;
-        }
-      } else if (event.section === "bitcoinLocks") {
-        if (client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
-          const { lockPrice, utxoId, accountId, vaultId } = event.data;
-          this.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})`,
-                ext.toHuman()?.method?.args
-              );
-            }
-          } else {
-            if (this.options.shouldLog) {
-              console.log(`x [Failed Tx] ${dispatchError.toJSON()}`);
-            }
-          }
-        }
-      }
-      if (this.options.shouldLog && logEvent) {
-        console.log(`> ${event.section}.${event.method}`, data);
-      }
-      this.events.emit("event", header, event);
-    }
-    if (reloadVaults.size) this.events.emit("vaults-updated", header, reloadVaults);
-    const tick = getTickFromHeader(client, header);
-    const author = getAuthorFromHeader(client, header);
-    this.events.emit(
-      "block",
-      header,
-      { tick, author },
-      events.map((x) => x.event)
-    );
-  }
-  async getBitcoinLockDetails(utxoId, blockHash) {
-    const client = await this.mainchain;
-    const api = await client.at(blockHash);
-    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];
-  }
-};
-
-// src/FrameCalculator.ts
-var FrameCalculator = class _FrameCalculator {
-  miningConfig;
-  genesisTick;
-  tickMillis;
-  async load(client) {
-    return await this.getConfig(client);
-  }
-  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);
-    return _FrameCalculator.calculateTickRangeForFrame(frameId, {
-      ticksBetweenFrames,
-      biddingStartTick
-    });
-  }
-  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);
-  }
-  static frameToDateRange(frameId, config2) {
-    const [start, end] = _FrameCalculator.calculateTickRangeForFrame(frameId, config2);
-    return [new Date(start * config2.tickMillis), new Date(end * config2.tickMillis)];
-  }
-  static calculateTickRangeForFrame(frameId, config2) {
-    const { ticksBetweenFrames, biddingStartTick } = config2;
-    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
-    const endingTick = startingTick + ticksBetweenFrames - 1;
-    return [startingTick, endingTick];
-  }
-  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());
-    this.tickMillis ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    const config2 = this.miningConfig;
-    const genesisTick = this.genesisTick;
-    return {
-      ticksBetweenFrames: config2.ticksBetweenSlots,
-      slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
-      genesisTick,
-      tickMillis: this.tickMillis,
-      biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
-    };
-  }
-};
-
-// src/AccountMiners.ts
-var AccountMiners = class _AccountMiners {
-  constructor(accountset, registeredMiners, options = { shouldLog: false }) {
-    this.accountset = accountset;
-    this.options = options;
-    this.frameCalculator = new FrameCalculator();
-    for (const miner of registeredMiners) {
-      this.trackedAccountsByAddress[miner.address] = {
-        startingFrameId: miner.seat.startingFrameId,
-        subaccountIndex: miner.subaccountIndex
-      };
-    }
-  }
-  events = createNanoEvents();
-  frameCalculator;
-  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: options.shouldLog ?? false
-    });
-  }
-};
-
-// src/Accountset.ts
-import { u8aToHex as u8aToHex2 } from "@polkadot/util";
-var Accountset = class {
-  txSubmitterPair;
-  isProxy = false;
-  seedAddress;
-  subAccountsByAddress = {};
-  accountRegistry;
-  client;
-  get addresses() {
-    return [this.seedAddress, ...Object.keys(this.subAccountsByAddress)];
-  }
-  get namedAccounts() {
-    return this.accountRegistry.namedAccounts;
-  }
-  sessionKeySeed;
-  constructor(options) {
-    if ("seedAccount" in options) {
-      this.txSubmitterPair = options.seedAccount;
-      this.seedAddress = options.seedAccount.address;
-      this.isProxy = false;
-    } else {
-      this.isProxy = options.isProxy;
-      this.txSubmitterPair = options.txSubmitter;
-      this.seedAddress = options.seedAddress;
-    }
-    this.sessionKeySeed = options.sessionKeySeedOrMnemonic;
-    this.accountRegistry = options.accountRegistry ?? AccountRegistry.factory(options.name);
-    this.client = options.client;
-    const defaultRange = options.subaccountRange ?? getDefaultSubaccountRange();
-    this.accountRegistry.register(this.seedAddress, `${this.accountRegistry.me}//seed`);
-    for (const i of defaultRange) {
-      const pair = this.txSubmitterPair.derive(`//${i}`);
-      this.subAccountsByAddress[pair.address] = { pair, index: i };
-      this.accountRegistry.register(pair.address, `${this.accountRegistry.me}//${i}`);
-    }
-  }
-  async submitterBalance(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const accountData = await api.query.system.account(this.txSubmitterPair.address);
-    return accountData.data.free.toBigInt();
-  }
-  async balance(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const accountData = await api.query.system.account(this.seedAddress);
-    return accountData.data.free.toBigInt();
-  }
-  async totalArgonsAt(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const addresses = this.addresses;
-    const results = await api.query.system.account.multi(addresses);
-    return results.map((account, i) => {
-      const address = addresses[i];
-      return {
-        address,
-        amount: account.data.free.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async totalArgonotsAt(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const addresses = this.addresses;
-    const results = await api.query.ownership.account.multi(addresses);
-    return results.map((account, i) => {
-      const address = addresses[i];
-      return {
-        address,
-        amount: account.free.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async getAvailableMinerAccounts(maxSeats) {
-    const miningSeats = await this.miningSeats();
-    const subaccountRange = [];
-    for (const seat of miningSeats) {
-      if (seat.hasWinningBid) {
-        continue;
-      }
-      if (seat.isLastDay || seat.seat === void 0) {
-        subaccountRange.push({
-          index: seat.subaccountIndex,
-          isRebid: seat.seat !== void 0,
-          address: seat.address
-        });
-        if (subaccountRange.length >= maxSeats) {
-          break;
-        }
-      }
-    }
-    return subaccountRange;
-  }
-  async loadRegisteredMiners(api) {
-    const addresses = Object.keys(this.subAccountsByAddress);
-    const rawIndices = await api.query.miningSlot.accountIndexLookup.multi(addresses);
-    const frameIds = [
-      ...new Set(
-        rawIndices.map((x) => x.isNone ? void 0 : x.value[0].toNumber()).filter((x) => x !== void 0)
-      )
-    ];
-    const bidAmountsByFrame = {};
-    if (frameIds.length) {
-      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 = bidAmountsByFrame[frameId]?.[index];
-      addressToMiningIndex[address] = {
-        startingFrameId: frameId,
-        index,
-        bidAmount: 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.startingFrameId === 10;
-      }
-      return {
-        address,
-        seat: cohort,
-        isLastDay,
-        subaccountIndex: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async miningSeats(blockHash) {
-    const client = await this.client;
-    const api = blockHash ? await client.at(blockHash) : client;
-    const miners = await this.loadRegisteredMiners(api);
-    const nextCohort = await api.query.miningSlot.bidsForNextSlotCohort();
-    return miners.map((miner) => {
-      const bid = nextCohort.find((x) => x.accountId.toHuman() === miner.address);
-      return {
-        ...miner,
-        hasWinningBid: !!bid,
-        bidAmount: bid?.bid.toBigInt() ?? miner.seat?.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: entry?.index,
-        bidAmount: entry?.bid?.toBigInt(),
-        index: this.subAccountsByAddress[address]?.index ?? Number.NaN
-      };
-    });
-  }
-  async consolidate(subaccounts) {
-    const client = await this.client;
-    const accounts = this.getAccountsInRange(subaccounts);
-    const results = [];
-    await Promise.allSettled(
-      accounts.map(({ pair, index }) => {
-        if (!pair) {
-          results.push({
-            index,
-            failedError: new Error(`No keypair for //${index}`)
-          });
-          return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-          client.tx.utility.batchAll([
-            client.tx.balances.transferAll(this.seedAddress, true),
-            client.tx.ownership.transferAll(this.seedAddress, true)
-          ]).signAndSend(pair, (cb) => {
-            logExtrinsicResult(cb);
-            if (cb.dispatchError) {
-              const error = dispatchErrorToString(client, cb.dispatchError);
-              results.push({
-                index,
-                failedError: new Error(`Error consolidating //${index}: ${error}`)
-              });
-              resolve();
-            }
-            if (cb.isInBlock) {
-              results.push({ index, inBlock: cb.status.asInBlock.toHex() });
-              resolve();
-            }
-          }).catch((e) => {
-            results.push({ index, failedError: e });
-            resolve();
-          });
-        });
-      })
-    );
-    return results;
-  }
-  status(opts) {
-    const { argons, argonots, accountSubset, bids, seats } = opts;
-    const accounts = [
-      {
-        index: "main",
-        address: this.seedAddress,
-        argons: formatArgons(argons.find((x) => x.address === this.seedAddress)?.amount ?? 0n),
-        argonots: formatArgons(argonots.find((x) => x.address === this.seedAddress)?.amount ?? 0n)
-      }
-    ];
-    for (const [address, { index }] of Object.entries(this.subAccountsByAddress)) {
-      const argonAmount = argons.find((x) => x.address === address)?.amount ?? 0n;
-      const argonotAmount = argonots.find((x) => x.address === address)?.amount ?? 0n;
-      const bid = bids.find((x) => x.address === address);
-      const seat = seats.find((x) => x.address === address)?.seat;
-      const entry = {
-        index: ` //${index}`,
-        address,
-        argons: formatArgons(argonAmount),
-        argonots: formatArgons(argonotAmount),
-        seat,
-        bidPlace: bid?.bidPlace,
-        bidAmount: bid?.bidAmount ?? 0n
-      };
-      if (accountSubset) {
-        entry.isWorkingOn = accountSubset.some((x) => x.address === address);
-      }
-      accounts.push(entry);
-    }
-    return accounts;
-  }
-  async registerKeys(url) {
-    const client = await getClient(url.replace("ws:", "http:"));
-    const keys = this.keys();
-    for (const [name, key] of Object.entries(keys)) {
-      console.log("Registering key", name, key.publicKey);
-      const result = await client.rpc.author.insertKey(name, key.privateKey, key.publicKey);
-      const saved = await client.rpc.author.hasKey(key.publicKey, name);
-      if (!saved) {
-        console.error("Failed to register key", name, key.publicKey);
-        throw new Error(`Failed to register ${name} key ${key.publicKey}`);
-      }
-      console.log(`Registered ${name} key`, result.toHuman());
-    }
-    await client.disconnect();
-  }
-  keys(keysVersion) {
-    const config2 = getConfig();
-    let version = keysVersion ?? config2.keysVersion ?? 0;
-    const seed = this.sessionKeySeed ?? config2.keySeedOrMnemonic;
-    if (!seed) {
-      throw new Error("KEYS_MNEMONIC environment variable not set. Cannot derive keys.");
-    }
-    const blockSealKey = `${seed}//block-seal//${version}`;
-    const granKey = `${seed}//grandpa//${version}`;
-    const blockSealAccount = new Keyring().createFromUri(blockSealKey, {
-      type: "ed25519"
-    });
-    const grandpaAccount = new Keyring().createFromUri(granKey, {
-      type: "ed25519"
-    });
-    return {
-      seal: {
-        privateKey: blockSealKey,
-        publicKey: u8aToHex2(blockSealAccount.publicKey),
-        rawPublicKey: blockSealAccount.publicKey
-      },
-      gran: {
-        privateKey: granKey,
-        publicKey: u8aToHex2(grandpaAccount.publicKey),
-        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(range ?? getDefaultSubaccountRange());
-    return Object.entries(this.subAccountsByAddress).filter(([_, account]) => {
-      return entries.has(account.index);
-    }).map(([address, { pair, index }]) => ({ pair, index, address }));
-  }
-  async watchBlocks(shouldLog = false) {
-    const accountMiners = await AccountMiners.loadAt(this, { shouldLog });
-    await accountMiners.watch();
-    return accountMiners;
-  }
-};
-function getDefaultSubaccountRange() {
-  try {
-    const config2 = getConfig();
-    return parseSubaccountRange(config2.subaccountRange ?? "0-9");
-  } catch {
-    console.error(
-      "Failed to parse SUBACCOUNT_RANGE configuration. Defaulting to 0-9. Please check the format of the subaccountRange config value."
-    );
-    return Array.from({ length: 10 }, (_, i) => i);
-  }
-}
-function parseSubaccountRange(range) {
-  if (!range) {
-    return void 0;
-  }
-  const indices = [];
-  for (const entry of range.split(",")) {
-    if (entry.includes("-")) {
-      const [start, end] = entry.split("-").map((x) => parseInt(x, 10));
-      for (let i = start; i <= end; i++) {
-        indices.push(i);
-      }
-      continue;
-    }
-    const record = parseInt(entry.trim(), 10);
-    if (Number.isNaN(record) || !Number.isInteger(record)) {
-      throw new Error(`Invalid range entry: ${entry}`);
-    }
-    if (Number.isInteger(record)) {
-      indices.push(record);
-    }
-  }
-  return indices;
-}
-
-// src/MiningBids.ts
-import { printTable } from "console-table-printer";
-var MiningBids = class {
-  constructor(client, shouldLog = true) {
-    this.client = client;
-    this.shouldLog = shouldLog;
-  }
-  nextCohort = [];
-  async maxCohortSize() {
-    const client = await this.client;
-    return client.query.miningSlot.nextCohortSize().then((x) => x.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 onBiddingEnd?.(openCohortStartingFrameId);
-          }
-          openCohortStartingFrameId = nextFrameId;
-          await onBiddingStart?.(nextFrameId);
-        } else {
-          await onBiddingEnd?.(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: accountNames.get(bid.accountId.toString()) ?? "n",
-      bidAmount: bid.bid.toBigInt()
-    };
-  }
-  print() {
-    const bids = this.nextCohort.map((bid) => {
-      return {
-        account: bid.accountId,
-        isOurs: bid.isOurs,
-        bidAmount: formatArgons(bid.bidAmount)
-      };
-    });
-    if (bids.length) {
-      console.log("\n\nMining Bids:");
-      printTable(bids);
-    }
-  }
-};
-
-// src/Vault.ts
-import BigNumber2, * as BN2 from "bignumber.js";
-import bs58check from "bs58check";
-import { hexToU8a } from "@polkadot/util";
-var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
-var Vault = class _Vault {
-  constructor(id, vault, tickDuration) {
-    this.tickDuration = tickDuration;
-    this.vaultId = id;
-    this.openedTick = vault.openedTick.toNumber();
-    this.openedDate = new Date(this.openedTick * this.tickDuration);
-    this.argonsScheduledForRelease = /* @__PURE__ */ new Map();
-    this.load(vault);
-  }
-  securitization;
-  argonsLocked;
-  argonsPendingActivation;
-  argonsScheduledForRelease;
-  terms;
-  operatorAccountId;
-  isClosed;
-  vaultId;
-  pendingTerms;
-  pendingTermsChangeTick;
-  openedDate;
-  openedTick;
-  securitizationRatio;
-  load(vault) {
-    this.securitization = vault.securitization.toBigInt();
-    this.securitizationRatio = convertFixedU128ToBigNumber(
-      vault.securitizationRatio.toBigInt()
-    ).toNumber();
-    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();
-    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()
-        )
-      };
-    }
-  }
-  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);
-  }
-  securitizationRatioBN() {
-    return new BigNumber2(this.securitizationRatio);
-  }
-  recoverySecuritization() {
-    const reserved = new BigNumber2(1).div(this.securitizationRatioBN());
-    return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
-  }
-  minimumSecuritization() {
-    return BigInt(
-      this.securitizationRatioBN().multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber2.ROUND_CEIL).toString()
-    );
-  }
-  activatedSecuritization() {
-    const activated = this.argonsLocked - this.argonsPendingActivation;
-    const maxRatio = BigNumber2(Math.min(this.securitizationRatio, 2));
-    return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
-  }
-  /**
-   * Returns the amount of Argons available to match per liquidity pool
-   */
-  activatedSecuritizationPerSlot() {
-    const activated = this.activatedSecuritization();
-    return activated / 10n;
-  }
-  calculateBitcoinFee(amount) {
-    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber2.ROUND_CEIL);
-    return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
-  }
-  static async get(client, vaultId, tickDurationMillis) {
-    const rawVault = await client.query.vaults.vaultsById(vaultId);
-    if (rawVault.isNone) {
-      throw new Error(`Vault with id ${vaultId} not found`);
-    }
-    const tickDuration = tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
-  }
-  static async create(client, keypair, args, config2 = {}) {
-    const {
-      securitization,
-      securitizationRatio,
-      annualPercentRate,
-      baseFee,
-      bitcoinXpub,
-      tip,
-      doNotExceedBalance,
-      txProgressCallback
-    } = args;
-    let xpubBytes = hexToU8a(bitcoinXpub);
-    if (xpubBytes.length !== 78) {
-      if (bitcoinXpub.startsWith("xpub") || bitcoinXpub.startsWith("tpub") || bitcoinXpub.startsWith("zpub")) {
-        const bytes = bs58check.decode(bitcoinXpub);
-        if (bytes.length !== 78) {
-          throw new Error("Invalid Bitcoin xpub key length, must be 78 bytes");
-        }
-        xpubBytes = bytes;
-      }
-    }
-    let vaultParams = {
-      terms: {
-        // convert to fixed u128
-        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
-        bitcoinBaseFee: BigInt(baseFee),
-        liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
-      },
-      securitizationRatio: toFixedNumber(securitizationRatio, 18),
-      securitization: BigInt(securitization),
-      bitcoinXpubkey: xpubBytes
-    };
-    let tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
-    if (doNotExceedBalance) {
-      const finalTip = tip ?? 0n;
-      let txFee = await tx.feeEstimate(finalTip);
-      while (txFee + finalTip + vaultParams.securitization > doNotExceedBalance) {
-        vaultParams.securitization = doNotExceedBalance - txFee - finalTip;
-        tx.tx = client.tx.vaults.create(vaultParams);
-        txFee = await tx.feeEstimate(finalTip);
-      }
-    }
-    const canAfford = await tx.canAfford({ tip, unavailableBalance: BigInt(securitization) });
-    if (!canAfford.canAfford) {
-      throw new Error(
-        `Insufficient balance to create vault. Required: ${formatArgons(securitization)}, Available: ${formatArgons(canAfford.availableBalance)}`
-      );
-    }
-    const result = await tx.submit({
-      tip,
-      useLatestNonce: true,
-      waitForBlock: true,
-      txProgressCallback
-    });
-    await result.inBlockPromise;
-    let vaultId;
-    for (const event of result.events) {
-      if (client.events.vaults.VaultCreated.is(event)) {
-        vaultId = event.data.vaultId.toNumber();
-        break;
-      }
-    }
-    if (vaultId === void 0) {
-      throw new Error("Vault creation failed, no VaultCreated event found");
-    }
-    const rawVault = await client.query.vaults.vaultsById(vaultId);
-    if (rawVault.isNone) {
-      throw new Error("Vault creation failed, vault not found");
-    }
-    const tickDuration = config2.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    const vault = new _Vault(vaultId, rawVault.unwrap(), tickDuration);
-    return { vault, txResult: result };
-  }
-};
-
-// src/VaultMonitor.ts
-import { printTable as printTable2 } from "console-table-printer";
-var VaultMonitor = class {
-  constructor(accountset, alerts = {}, options = {}) {
-    this.accountset = accountset;
-    this.alerts = alerts;
-    this.options = options;
-    this.mainchain = accountset.client;
-    if (options.vaultOnlyWatchMode !== void 0) {
-      this.vaultOnlyWatchMode = options.vaultOnlyWatchMode;
-    }
-    if (options.shouldLog !== void 0) {
-      this.shouldLog = options.shouldLog;
-    }
-    this.miningBids = new MiningBids(this.mainchain, this.shouldLog);
-    this.blockWatch = new BlockWatch(this.mainchain, {
-      shouldLog: this.shouldLog
-    });
-    this.blockWatch.events.on(
-      "vaults-updated",
-      (header, vaultIds) => this.onVaultsUpdated(header.hash, vaultIds)
-    );
-    this.blockWatch.events.on("mining-bid", async (header, _bid) => {
-      await this.miningBids.loadAt(this.accountset.namedAccounts, header.hash);
-      this.printBids(header.hash);
-    });
-    this.blockWatch.events.on("mining-bid-ousted", async (header) => {
-      await this.miningBids.loadAt(this.accountset.namedAccounts, header.hash);
-      this.printBids(header.hash);
-    });
-  }
-  events = createNanoEvents();
-  vaultsById = {};
-  blockWatch;
-  mainchain;
-  activatedCapitalByVault = {};
-  lastPrintedBids;
-  miningBids;
-  tickDuration = 0;
-  vaultOnlyWatchMode = false;
-  shouldLog = true;
-  stop() {
-    this.blockWatch.stop();
-  }
-  async monitor(justPrint = false) {
-    const client = await this.mainchain;
-    this.tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
-    const blockHeader = await client.rpc.chain.getHeader();
-    const blockHash = new Uint8Array(blockHeader.hash);
-    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}x`,
-        securActivated: `${formatArgons(vault.activatedSecuritizationPerSlot())}/slot`,
-        liquidPoolDeal: `${formatPercent(vault.terms.liquidityPoolProfitSharing)} sharing`,
-        operator: `${this.accountset.namedAccounts.has(vault.operatorAccountId) ? ` (${this.accountset.namedAccounts.get(vault.operatorAccountId)})` : vault.operatorAccountId}`,
-        state: vault.isClosed ? "closed" : vault.openedDate < /* @__PURE__ */ new Date() ? "open" : "pending"
-      });
-    }
-    if (vaults.length) {
-      if (this.vaultOnlyWatchMode) {
-        console.clear();
-      }
-      console.log("\n\nVaults:");
-      printTable2(vaults);
-    }
-  }
-  async recheckAfterActive(vaultId) {
-    const activationDate = this.vaultsById[vaultId].openedDate;
-    if (this.shouldLog) {
-      console.log(`Waiting for vault ${vaultId} to activate ${activationDate}`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, activationDate.getTime() - Date.now()));
-    const client = await this.mainchain;
-    let isReady = false;
-    while (!isReady) {
-      const rawVault = await client.query.vaults.vaultsById(vaultId);
-      if (!rawVault.isSome) return;
-      const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
-      this.vaultsById[vaultId] = vault;
-      if (vault.isClosed) return;
-      if (vault.openedDate < /* @__PURE__ */ new Date()) {
-        isReady = true;
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    this.checkAlerts(vaultId, this.vaultsById[vaultId]);
-  }
-  async onVaultsUpdated(blockHash, vaultIds) {
-    await this.reloadVaultsAt([...vaultIds], blockHash).catch((err) => {
-      console.error(`Failed to reload vault ${[...vaultIds]} at block ${blockHash}:`, err);
-    });
-    this.printVaults();
-  }
-  async reloadVaultsAt(vaultIds, blockHash) {
-    const client = await this.mainchain;
-    const api = await client.at(blockHash);
-    const vaults = await api.query.vaults.vaultsById.multi(vaultIds);
-    for (let i = 0; i < vaultIds.length; i += 1) {
-      this.updateVault(vaultIds[i], vaults[i]);
-    }
-  }
-  updateVault(vaultId, rawVault) {
-    if (rawVault.isNone) return;
-    const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
-    this.vaultsById[vaultId] = vault;
-    if (vault.openedDate > /* @__PURE__ */ new Date()) {
-      void this.recheckAfterActive(vaultId);
-    } else {
-      this.checkAlerts(vaultId, vault);
-    }
-  }
-  checkAlerts(vaultId, vault) {
-    if (this.alerts.bitcoinSpaceAvailable !== void 0) {
-      const availableBitcoinSpace = vault.availableBitcoinSpace();
-      if (availableBitcoinSpace >= this.alerts.bitcoinSpaceAvailable) {
-        console.warn(
-          `Vault ${vaultId} has available bitcoins above ${formatArgons(this.alerts.bitcoinSpaceAvailable)}`
-        );
-        this.events.emit("bitcoin-space-above", vaultId, availableBitcoinSpace);
-      }
-    }
-  }
-  checkMiningBondAlerts(vaultId, vault) {
-    if (this.alerts.liquidityPoolSpaceAvailable === void 0) return;
-    const activatedSecuritization = vault.activatedSecuritizationPerSlot();
-    const capitalization = this.activatedCapitalByVault[vaultId] ?? 0n;
-    const available = activatedSecuritization - capitalization;
-    if (available >= this.alerts.liquidityPoolSpaceAvailable) {
-      this.events.emit("liquidity-pool-space-above", vaultId, available);
-    }
-  }
-  printBids(blockHash) {
-    if (!this.shouldLog) return;
-    if (this.lastPrintedBids === blockHash) return;
-    this.miningBids.print();
-    this.lastPrintedBids = blockHash;
-  }
-};
-
-// src/CohortBidder.ts
-var CohortBidder = class {
-  constructor(accountset, cohortStartingFrameId, subaccounts, options, callbacks) {
-    this.accountset = accountset;
-    this.cohortStartingFrameId = cohortStartingFrameId;
-    this.subaccounts = subaccounts;
-    this.options = options;
-    this.callbacks = callbacks;
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  get clientPromise() {
-    return this.accountset.client;
-  }
-  txFees = 0n;
-  bidsAttempted = 0;
-  winningBids = [];
-  myAddresses = /* @__PURE__ */ new Set();
-  currentBids = {
-    bids: [],
-    mostRecentBidTick: 0,
-    atTick: 0,
-    atBlockNumber: 0
-  };
-  unsubscribe;
-  pendingRequest;
-  isStopped = false;
-  millisPerTick;
-  minIncrement = 10000n;
-  nextCohortSize;
-  lastBidTick = 0;
-  evaluateInterval;
-  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.clientPromise;
-    this.minIncrement = client.consts.miningSlot.bidIncrements.toBigInt();
-    this.nextCohortSize = await client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
-    if (this.subaccounts.length > this.nextCohortSize) {
-      console.info(
-        `Cohort size ${this.nextCohortSize} is less than provided subaccounts ${this.subaccounts.length}.`
-      );
-      this.subaccounts.length = this.nextCohortSize;
-    }
-    this.millisPerTick = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    let didStart = false;
-    this.unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.bidsForNextSlotCohort,
-        client.query.miningSlot.nextFrameId,
-        client.query.ticks.currentTick,
-        client.query.system.number
-      ],
-      async ([rawBids, nextFrameId, currentTick, blockNumber]) => {
-        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
-          this.updateBidList(rawBids, blockNumber.toNumber(), currentTick.toNumber());
-          if (!didStart) {
-            didStart = true;
-            this.scheduleEvaluation();
-            void this.checkWinningBids();
-          }
-        }
-      }
-    );
-  }
-  async stop() {
-    if (this.isStopped) return this.winningBids;
-    this.isStopped = true;
-    clearInterval(this.evaluateInterval);
-    console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
-    if (this.unsubscribe) {
-      this.unsubscribe();
-    }
-    const client = await this.clientPromise;
-    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;
-    const currentFrameId = await client.query.miningSlot.nextFrameId();
-    let blockNumber;
-    if (currentFrameId.toNumber() > this.cohortStartingFrameId) {
-      blockNumber = await client.query.miningSlot.frameStartBlockNumbers().then((x) => x[0]?.toNumber()) - 1;
-    } else {
-      blockNumber = await client.query.system.number().then((x) => x.toNumber());
-    }
-    const blockHash = await client.rpc.chain.getBlockHash(blockNumber);
-    const api = await client.at(blockHash);
-    const rawBids = await api.query.miningSlot.bidsForNextSlotCohort();
-    const currentTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    this.updateBidList(rawBids, blockNumber, currentTick);
-    console.log("Bidder stopped", {
-      cohortStartingFrameId: this.cohortStartingFrameId,
-      blockNumber,
-      winningBids: this.winningBids
-    });
-    return this.winningBids;
-  }
-  async checkWinningBids() {
-    if (this.isStopped) return;
-    if (this.pendingRequest) {
-      console.log("Current bid is still in progress, skipping this check");
-      return;
-    }
-    if (this.currentBids.mostRecentBidTick < this.lastBidTick) {
-      console.log(`Waiting for bids more recent than our last attempt.`, {
-        ownAttemptedBidTick: this.lastBidTick,
-        liveBidsTick: this.currentBids.mostRecentBidTick
-      });
-      return;
-    }
-    const bids = [...this.currentBids.bids];
-    const bidsAtTick = this.currentBids.atTick;
-    const blockNumber = this.currentBids.atBlockNumber;
-    const winningBids = bids.filter((x) => this.myAddresses.has(x.address));
-    if (winningBids.length >= this.subaccounts.length) {
-      console.log(`No updates needed. Winning all remaining seats (${winningBids.length}).`);
-      return;
-    }
-    console.log(
-      `Checking bids for cohort ${this.cohortStartingFrameId}, Still trying for seats: ${this.subaccounts.length}`
-    );
-    const winningAddresses = new Set(winningBids.map((x) => x.address));
-    let lowestBid;
-    let myAllocatedBids = 0n;
-    for (const bid of bids) {
-      lowestBid ??= bid.bidMicrogons;
-      if (this.myAddresses.has(bid.address)) {
-        myAllocatedBids += bid.bidMicrogons;
-      } else {
-        if (bid.bidMicrogons < lowestBid) {
-          lowestBid = bid.bidMicrogons;
-        }
-      }
-    }
-    lowestBid ??= -this.options.bidIncrement;
-    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 this.accountset.submitterBalance();
-    availableBalanceForBids += myAllocatedBids;
-    const tip = this.options.tipPerTransaction ?? 0n;
-    const feeEstimate = await fakeTx.feeEstimate(tip);
-    const estimatedFeePlusTip = feeEstimate + tip;
-    let budgetForSeats = this.options.maxBudget - estimatedFeePlusTip;
-    if (budgetForSeats > availableBalanceForBids) {
-      budgetForSeats = availableBalanceForBids - estimatedFeePlusTip;
-    }
-    if (nextBid < lowestBid) {
-      console.log(
-        `Next bid within parameters is ${formatArgons(nextBid)}, but it's not enough. Current lowest bid is ${formatArgons(lowestBid)}.`
-      );
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: 0,
-        winningBidCount: winningBids.length,
-        reason: "max-bid-too-low",
-        availableBalanceForBids
-      });
-      return;
-    }
-    if (nextBid - lowestBid < Number(this.minIncrement)) {
-      console.log(
-        `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints (next bid below min increment).`,
-        {
-          lowestCurrentBid: formatArgons(lowestBid),
-          nextAttemptedBid: formatArgons(nextBid),
-          maxBid: formatArgons(this.options.maxBid)
-        }
-      );
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: 0,
-        winningBidCount: winningBids.length,
-        reason: "max-bid-too-low",
-        availableBalanceForBids
-      });
-      return;
-    }
-    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
-    let accountsToUse = [...this.subaccounts];
-    if (accountsToUse.length > seatsInBudget) {
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: this.subaccounts.length,
-        winningBidCount: winningBids.length,
-        reason: availableBalanceForBids - estimatedFeePlusTip < nextBid * BigInt(seatsInBudget) ? "insufficient-balance" : "max-budget-too-low",
-        availableBalanceForBids
-      });
-      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.length) {
-      this.pendingRequest = this.submitBids(nextBid, accountsToUse);
-    }
-  }
-  async submitBids(microgonsPerSeat, subaccounts) {
-    try {
-      this.bidsAttempted += subaccounts.length;
-      const submitter = await this.accountset.createMiningBidTx({
-        subaccounts,
-        bidAmount: microgonsPerSeat
-      });
-      const tip = this.options.tipPerTransaction ?? 0n;
-      const txResult = await submitter.submit({
-        tip,
-        useLatestNonce: true
-      });
-      const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
-      const client = await this.clientPromise;
-      let api = txResult.includedInBlock ? await client.at(txResult.includedInBlock) : client;
-      this.lastBidTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-      const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-      const bidAtTick = this.lastBidTick;
-      try {
-        this.callbacks?.onBidsSubmitted?.({
-          tick: bidAtTick,
-          blockNumber,
-          microgonsPerSeat,
-          txFeePlusTip: txResult.finalFee ?? 0n,
-          submittedCount: subaccounts.length
-        });
-      } catch (error) {
-        console.error("Error in onBidsSubmitted callback:", error);
-      }
-      const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
-      this.txFees += txResult.finalFee ?? 0n;
-      console.log("Result of bids for cohort", {
-        successfulBids,
-        bidsPlaced: subaccounts.length,
-        bidPerSeat: formatArgons(microgonsPerSeat),
-        bidAtTick
-      });
-      if (bidError) {
-        try {
-          this.callbacks?.onBidsRejected?.({
-            tick: bidAtTick,
-            blockNumber,
-            microgonsPerSeat,
-            submittedCount: subaccounts.length,
-            rejectedCount: subaccounts.length - successfulBids,
-            bidError
-          });
-        } catch (error) {
-          console.error("Error in onBidsRejected callback:", error);
-        }
-        throw bidError;
-      }
-    } catch (err) {
-      console.error(`Error bidding for cohort ${this.cohortStartingFrameId}:`, err);
-    } finally {
-      this.pendingRequest = void 0;
-      this.scheduleEvaluation();
-    }
-  }
-  scheduleEvaluation() {
-    if (this.isStopped) return;
-    const millisPerTick = this.millisPerTick;
-    const delayTicks = Math.max(this.options.bidDelay, 1);
-    const delay = delayTicks * millisPerTick;
-    if (this.evaluateInterval) clearInterval(this.evaluateInterval);
-    console.log(`Scheduling next evaluation in ${delay}ms`);
-    this.evaluateInterval = setInterval(() => this.checkWinningBids().catch(console.error), delay);
-  }
-  updateBidList(rawBids, blockNumber, tick) {
-    try {
-      let mostRecentBidTick = 0;
-      let hasDiffs = this.currentBids.bids.length !== rawBids.length;
-      const bids = [];
-      for (let i = 0; i < rawBids.length; i += 1) {
-        const rawBid = rawBids[i];
-        const bidAtTick = rawBid.bidAtTick.toNumber();
-        if (bidAtTick > mostRecentBidTick) {
-          mostRecentBidTick = bidAtTick;
-        }
-        const address = rawBid.accountId.toHuman();
-        const bidMicrogons = rawBid.bid.toBigInt();
-        if (!hasDiffs) {
-          const existing = this.currentBids.bids[i];
-          hasDiffs = existing?.address !== address || existing?.bidMicrogons !== bidMicrogons;
-        }
-        bids.push({
-          address,
-          bidMicrogons,
-          bidAtTick
-        });
-      }
-      if (blockNumber > this.currentBids.atBlockNumber && hasDiffs) {
-        this.currentBids.bids = bids;
-        this.currentBids.mostRecentBidTick = mostRecentBidTick;
-        this.currentBids.atTick = tick;
-        this.currentBids.atBlockNumber = blockNumber;
-        this.winningBids = bids.filter((x) => this.myAddresses.has(x.address));
-        console.log("Now winning bids:", this.winningBids.length);
-        if (this.callbacks?.onBidsUpdated) {
-          this.callbacks.onBidsUpdated({
-            bids: this.winningBids,
-            atBlockNumber: blockNumber,
-            tick: mostRecentBidTick
-          });
-        }
-      }
-    } catch (err) {
-      console.error("Error processing updated bids list:", err);
-    }
-  }
-  safeRecordParamsAdjusted(args) {
-    try {
-      this.callbacks?.onBidParamsAdjusted?.(args);
-    } catch (err) {
-      console.error("Error in onBidParamsAdjusted callback:", err);
-    }
-  }
-};
-
-// src/BidPool.ts
-import { Table } from "console-table-printer";
-var EMPTY_TABLE = {
-  headerBottom: { left: " ", mid: " ", other: "\u2500", right: " " },
-  headerTop: { left: " ", mid: " ", other: " ", right: " " },
-  rowSeparator: { left: " ", mid: " ", other: " ", right: " " },
-  tableBottom: { left: " ", mid: " ", other: " ", right: " " },
-  vertical: " "
-};
-var BidPool = class {
-  constructor(client, keypair, accountRegistry = AccountRegistry.factory()) {
-    this.client = client;
-    this.keypair = keypair;
-    this.accountRegistry = accountRegistry;
-    this.blockWatch = new BlockWatch(client, { shouldLog: false });
-  }
-  bidPoolAmount = 0n;
-  nextFrameId = 1;
-  poolVaultCapitalByFrame = {};
-  vaultSecuritization = [];
-  printTimeout;
-  blockWatch;
-  vaultsById = {};
-  tickDuration;
-  lastDistributedFrameId;
-  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 ??= new Uint8Array((await client.rpc.chain.getHeader()).hash);
-    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();
-        this.FrameSubscriptions[rawFrameId.toNumber()]?.();
-        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: options?.tip,
-      unavailableBalance: amount
-    });
-    if (!affordability.canAfford) {
-      console.warn("Insufficient balance to bond argons to liquidity pool", {
-        ...affordability,
-        argonsNeeded: amount
-      });
-      throw new Error("Insufficient balance to bond argons to liquidity pool");
-    }
-    const result = await txSubmitter.submit({
-      tip: options?.tip,
-      useLatestNonce: true
-    });
-    await result.inBlockPromise;
-    return result;
-  }
-  printDebounce() {
-    if (this.printTimeout) {
-      clearTimeout(this.printTimeout);
-    }
-    this.printTimeout = setTimeout(() => {
-      this.print();
-    }, 100);
-  }
-  getOperatorName(vaultId) {
-    const vault = this.vaultsById[vaultId];
-    return this.accountRegistry.getName(vault.operatorAccountId) ?? vault.operatorAccountId;
-  }
-  print() {
-    console.clear();
-    const lastDistributedFrameId = this.lastDistributedFrameId;
-    const distributedFrame = this.poolVaultCapitalByFrame[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(
-          entry.earnings ?? 0n,
-          entry.contributors ?? [],
-          `Earnings (shared = ${formatPercent(entry.vaultSharingPercent)})`
-        );
-        if (width > maxWidth2) {
-          maxWidth2 = width;
-        }
-        rows.push({
-          Vault: key,
-          Who: this.getOperatorName(Number(key)),
-          Balances: table
-        });
-      }
-      new Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Who", alignment: "left" },
-          {
-            name: "Balances",
-            title: "Contributor Balances",
-            alignment: "center",
-            minLen: maxWidth2
-          }
-        ],
-        rows
-      }).printTable();
-    }
-    console.log(
-      `
-
-Active Bid Pool: ${formatArgons(this.bidPoolAmount)} (Frame ${this.nextFrameId})`
-    );
-    const Frame = this.poolVaultCapitalByFrame[this.nextFrameId];
-    if (Object.keys(Frame ?? {}).length > 0) {
-      const rows = [];
-      let maxWidth2 = 0;
-      for (const [key, entry] of Object.entries(Frame)) {
-        const { table, width } = this.createBondCapitalTable(
-          entry.activatedCapital,
-          entry.contributors ?? []
-        );
-        if (width > maxWidth2) {
-          maxWidth2 = width;
-        }
-        rows.push({
-          Vault: key,
-          Who: this.getOperatorName(Number(key)),
-          "Pool Capital": table
-        });
-      }
-      new Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Who", alignment: "left" },
-          { name: "Pool Capital", alignment: "left", minLen: maxWidth2 }
-        ],
-        rows
-      }).printTable();
-    }
-    const raisingFunds = this.poolVaultCapitalByFrame[this.nextFrameId + 1] ?? [];
-    let maxWidth = 0;
-    const nextCapital = [];
-    for (const x of this.vaultSecuritization) {
-      const entry = raisingFunds[x.vaultId] ?? {};
-      const { table, width } = this.createBondCapitalTable(
-        x.activatedSecuritization,
-        entry.contributors ?? []
-      );
-      if (width > maxWidth) {
-        maxWidth = width;
-      }
-      nextCapital.push({
-        Vault: x.vaultId,
-        Owner: this.getOperatorName(x.vaultId),
-        "Bitcoin Space": formatArgons(x.bitcoinSpace),
-        "Activated Securitization": `${formatArgons(x.activatedSecuritization)} / slot`,
-        "Liquidity Pool": `${formatPercent(x.vaultSharingPercent)} profit sharing${table}`
-      });
-    }
-    if (nextCapital.length) {
-      console.log(`
-
-Raising Funds (Frame ${this.nextFrameId + 1}):`);
-      new Table({
-        columns: [
-          { name: "Vault", alignment: "left" },
-          { name: "Owner", alignment: "left" },
-          { name: "Bitcoin Space", alignment: "right" },
-          { name: "Activated Securitization", alignment: "right" },
-          { name: "Liquidity Pool", alignment: "left", minLen: maxWidth }
-        ],
-        rows: nextCapital
-      }).printTable();
-    }
-  }
-  setVaultFrameData(frameId, vaultId, data) {
-    this.poolVaultCapitalByFrame ??= {};
-    this.poolVaultCapitalByFrame[frameId] ??= {};
-    this.poolVaultCapitalByFrame[frameId][vaultId] ??= {
-      activatedCapital: data.activatedCapital ?? data.contributors?.reduce((a, b) => a + b.amount, 0n) ?? 0n
-    };
-    Object.assign(this.poolVaultCapitalByFrame[frameId][vaultId], filterUndefined(data));
-  }
-  createBondCapitalTable(total, contributors, title = "Total") {
-    const table = new Table({
-      style: EMPTY_TABLE,
-      columns: [
-        { name: "who", title, minLen: 10, alignment: "right" },
-        {
-          name: "amount",
-          title: formatArgons(total),
-          minLen: 7,
-          alignment: "left"
-        }
-      ]
-    });
-    for (const x of contributors) {
-      table.addRow({
-        who: this.accountRegistry.getName(x.address) ?? x.address,
-        amount: formatArgons(x.amount)
-      });
-    }
-    const str = table.render();
-    const width = str.indexOf("\n");
-    return { table: str, width };
-  }
-  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 > (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
-      });
-    }
-  }
-};
-
-// src/BitcoinLocks.ts
-import { hexToU8a as hexToU8a2, u8aToHex as u8aToHex3 } from "@polkadot/util";
-var SATS_PER_BTC = 100000000n;
-var BitcoinLocks = class _BitcoinLocks {
-  constructor(client) {
-    this.client = client;
-  }
-  async getUtxoIdFromEvents(events) {
-    const client = await this.client;
-    for (const event of events) {
-      if (client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
-        return event.data.utxoId.toNumber();
-      }
-    }
-    return void 0;
-  }
-  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 getRedemptionRate(satoshis) {
-    const client = await this.client;
-    const sats = client.createType("U64", satoshis.toString());
-    const marketRate = await client.rpc.state.call("BitcoinApis_redemption_rate", sats.toHex(true));
-    const rate = client.createType("Option<U128>", marketRate);
-    if (!rate.isSome) {
-      throw new Error("Redemption rate not available");
-    }
-    return rate.value.toBigInt();
-  }
-  async getConfig() {
-    const client = await this.client;
-    const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
-    return {
-      lockReleaseCosignDeadlineFrames: client.consts.bitcoinLocks.lockReleaseCosignDeadlineFrames.toNumber(),
-      pendingConfirmationExpirationBlocks: client.consts.bitcoinUtxos.maxPendingConfirmationBlocks.toNumber(),
-      tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
-      bitcoinNetwork
-    };
-  }
-  async getBitcoinConfirmedBlockHeight() {
-    const client = await this.client;
-    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.value?.blockHeight.toNumber() ?? 0);
-  }
-  /**
-   * Gets the UTXO reference by ID.
-   * @param utxoId - The UTXO ID to look up.
-   * @param atHeight - Optional block height to query the UTXO reference at a specific point in time.
-   * @return An object containing the transaction ID and output index, or undefined if not found.
-   * @return.txid - The Bitcoin transaction ID of the UTXO.
-   * @return.vout - The output index of the UTXO in the transaction.
-   * @return.bitcoinTxid - The Bitcoin transaction ID of the UTXO formatted in little endian
-   */
-  async getUtxoRef(utxoId, atHeight) {
-    let client = await this.client;
-    if (atHeight !== void 0) {
-      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
-      client = await client.at(blockHash);
-    }
-    const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
-    if (!refRaw) {
-      return;
-    }
-    const ref = refRaw.unwrap();
-    const txid = u8aToHex3(ref.txid);
-    const bitcoinTxid = u8aToHex3(ref.txid.reverse());
-    const vout = ref.outputIndex.toNumber();
-    return { txid, vout, bitcoinTxid };
-  }
-  async getReleaseRequest(utxoId, atHeight) {
-    let client = await this.client;
-    if (atHeight !== void 0) {
-      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
-      client = await client.at(blockHash);
-    }
-    const requestMaybe = await client.query.bitcoinLocks.lockReleaseRequestsByUtxoId(utxoId);
-    if (!requestMaybe.isSome) {
-      return void 0;
-    }
-    const request = requestMaybe.unwrap();
-    return {
-      toScriptPubkey: request.toScriptPubkey.toHex(),
-      bitcoinNetworkFee: request.bitcoinNetworkFee.toBigInt(),
-      dueFrame: request.cosignDueFrame.toNumber(),
-      vaultId: request.vaultId.toNumber(),
-      redemptionPrice: request.redemptionPrice.toBigInt()
-    };
-  }
-  async submitVaultSignature(args) {
-    const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
-    const client = await this.client;
-    if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
-      throw new Error(
-        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
-      );
-    }
-    const signature = u8aToHex3(vaultSignature);
-    const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
-    const submitter = new TxSubmitter(client, tx, argonKeyring);
-    return await submitter.submit({ txProgressCallback });
-  }
-  async getBitcoinLock(utxoId) {
-    const client = await this.client;
-    const utxoRaw = await client.query.bitcoinLocks.locksByUtxoId(utxoId);
-    if (!utxoRaw.isSome) {
-      return;
-    }
-    const utxo = utxoRaw.unwrap();
-    const p2shBytesPrefix = "0020";
-    const wscriptHash = utxo.utxoScriptPubkey.asP2wsh.wscriptHash.toHex().replace("0x", "");
-    const p2wshScriptHashHex = `0x${p2shBytesPrefix}${wscriptHash}`;
-    const vaultId = utxo.vaultId.toNumber();
-    const lockPrice = utxo.lockPrice.toBigInt();
-    const ownerAccount = utxo.ownerAccount.toHuman();
-    const satoshis = utxo.satoshis.toBigInt();
-    const vaultPubkey = utxo.vaultPubkey.toHex();
-    const vaultClaimPubkey = utxo.vaultClaimPubkey.toHex();
-    const ownerPubkey = utxo.ownerPubkey.toHex();
-    const [fingerprint, cosign_hd_index, claim_hd_index] = utxo.vaultXpubSources;
-    const vaultXpubSources = {
-      parentFingerprint: new Uint8Array(fingerprint),
-      cosignHdIndex: cosign_hd_index.toNumber(),
-      claimHdIndex: claim_hd_index.toNumber()
-    };
-    const vaultClaimHeight = utxo.vaultClaimHeight.toNumber();
-    const openClaimHeight = utxo.openClaimHeight.toNumber();
-    const createdAtHeight = utxo.createdAtHeight.toNumber();
-    const isVerified = utxo.isVerified.toJSON();
-    const isRejectedNeedsRelease = utxo.isRejectedNeedsRelease.toJSON();
-    const fundHoldExtensionsByBitcoinExpirationHeight = Object.fromEntries(
-      [...utxo.fundHoldExtensions.entries()].map(([x, y]) => [x.toNumber(), y.toBigInt()])
-    );
-    return {
-      utxoId,
-      p2wshScriptHashHex,
-      vaultId,
-      lockPrice,
-      ownerAccount,
-      satoshis,
-      vaultPubkey,
-      vaultClaimPubkey,
-      ownerPubkey,
-      vaultXpubSources,
-      vaultClaimHeight,
-      openClaimHeight,
-      createdAtHeight,
-      isVerified,
-      isRejectedNeedsRelease,
-      fundHoldExtensionsByBitcoinExpirationHeight
-    };
-  }
-  /**
-   * Finds the cosign signature for a vault lock by UTXO ID. Optionally waits for the signature
-   * @param utxoId - The UTXO ID of the bitcoin lock
-   * @param waitForSignatureMillis - Optional timeout in milliseconds to wait for the signature. If -1, waits indefinitely.
-   */
-  async findVaultCosignSignature(utxoId, waitForSignatureMillis) {
-    const client = await this.client;
-    const releaseHeight = await client.query.bitcoinLocks.lockReleaseCosignHeightById(utxoId);
-    if (releaseHeight.isSome) {
-      const releaseHeightValue = releaseHeight.unwrap().toNumber();
-      const signature = await this.getVaultCosignSignature(utxoId, releaseHeightValue);
-      if (signature) {
-        return { blockHeight: releaseHeightValue, signature };
-      }
-    }
-    if (!waitForSignatureMillis) {
-      return void 0;
-    }
-    return await new Promise(async (resolve, reject) => {
-      let timeout;
-      const unsub = await client.rpc.chain.subscribeNewHeads((header) => {
-        const atHeight = header.number.toNumber();
-        this.getVaultCosignSignature(utxoId, atHeight).then((signature) => {
-          if (signature) {
-            unsub?.();
-            clearTimeout(timeout);
-            resolve({ signature, blockHeight: atHeight });
-          }
-        }).catch((err) => {
-          console.error(`Error checking for cosign signature at height ${atHeight}:`, err);
-        });
-      });
-      if (waitForSignatureMillis !== -1) {
-        timeout = setTimeout(() => {
-          unsub?.();
-          reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${utxoId}`));
-        }, waitForSignatureMillis);
-      }
-    });
-  }
-  async blockHashAtHeight(atHeight) {
-    const client = await this.client;
-    for (let i = 0; i < 10; i++) {
-      const currentHeight = await client.query.system.number().then((x) => x.toNumber());
-      if (atHeight > currentHeight) {
-        console.warn(
-          `Requested block height ${atHeight} is greater than current height ${currentHeight}. Retrying...`
-        );
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        continue;
-      }
-      const hash = await client.rpc.chain.getBlockHash(atHeight).then((x) => x.toHex());
-      if (hash === "0x0000000000000000000000000000000000000000000000000000000000000000") {
-        console.warn(`Block hash not found for height ${atHeight}. Retrying...`);
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        continue;
-      }
-      return hash;
-    }
-    return void 0;
-  }
-  async getVaultCosignSignature(utxoId, atHeight) {
-    const client = await this.client;
-    const blockHash = await this.blockHashAtHeight(atHeight);
-    if (!blockHash) {
-      console.warn(`Block hash not found for height ${atHeight}`);
-      return void 0;
-    }
-    const blockEvents = await client.at(blockHash).then((api) => api.query.system.events());
-    for (const event of blockEvents) {
-      if (client.events.bitcoinLocks.BitcoinUtxoCosigned.is(event.event)) {
-        const { utxoId: id, signature } = event.event.data;
-        if (id.toNumber() === utxoId) {
-          return new Uint8Array(signature);
-        }
-      }
-    }
-    return void 0;
-  }
-  async findPendingMints(utxoId) {
-    const client = await this.client;
-    const pendingMint = await client.query.mint.pendingMintUtxos();
-    const mintsPending = [];
-    for (const [utxoIdRaw, _accountId, mintAmountRaw] of pendingMint) {
-      if (utxoIdRaw.toNumber() === utxoId) {
-        mintsPending.push(mintAmountRaw.toBigInt());
-      }
-    }
-    return mintsPending;
-  }
-  async createInitializeLockTx(args) {
-    const { vault, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
-    const client = await this.client;
-    if (ownerBitcoinPubkey.length !== 33) {
-      throw new Error(
-        `Invalid Bitcoin key length: ${ownerBitcoinPubkey.length}. Must be a compressed pukey (33 bytes).`
-      );
-    }
-    const tx = client.tx.bitcoinLocks.initialize(vault.vaultId, satoshis, ownerBitcoinPubkey);
-    const submitter = new TxSubmitter(
-      client,
-      client.tx.bitcoinLocks.initialize(vault.vaultId, satoshis, ownerBitcoinPubkey),
-      argonKeyring
-    );
-    const marketPrice = await this.getMarketRate(BigInt(satoshis));
-    const isVaultOwner = argonKeyring.address === vault.operatorAccountId;
-    const securityFee = isVaultOwner ? 0n : vault.calculateBitcoinFee(marketPrice);
-    const { canAfford, availableBalance, txFee } = await submitter.canAfford({
-      tip,
-      unavailableBalance: securityFee + (args.reducedBalanceBy ?? 0n),
-      includeExistentialDeposit: true
-    });
-    if (!canAfford) {
-      throw new Error(
-        `Insufficient funds to initialize lock. Available: ${formatArgons(availableBalance)}, Required: ${satoshis}`
-      );
-    }
-    return { tx, securityFee, txFee };
-  }
-  async getBitcoinLockFromTxResult(txResult) {
-    const client = await this.client;
-    const blockHash = await txResult.inBlockPromise;
-    const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
-    const utxoId = await this.getUtxoIdFromEvents(txResult.events) ?? 0;
-    if (utxoId === 0) {
-      throw new Error("Bitcoin lock creation failed, no UTXO ID found in transaction events");
-    }
-    const lock = await this.getBitcoinLock(utxoId);
-    if (!lock) {
-      throw new Error(`Lock with ID ${utxoId} not found after initialization`);
-    }
-    return { lock, createdAtHeight: blockHeight, txResult };
-  }
-  async initializeLock(args) {
-    const { argonKeyring, tip = 0n, txProgressCallback } = args;
-    const client = await this.client;
-    const { tx, securityFee } = await this.createInitializeLockTx(args);
-    const submitter = new TxSubmitter(client, tx, argonKeyring);
-    const txResult = await submitter.submit({
-      waitForBlock: true,
-      logResults: true,
-      tip,
-      txProgressCallback
-    });
-    const { lock, createdAtHeight } = await this.getBitcoinLockFromTxResult(txResult);
-    return {
-      lock,
-      createdAtHeight,
-      txResult,
-      securityFee
-    };
-  }
-  async requiredSatoshisForArgonLiquidity(argonAmount) {
-    const marketRatePerBitcoin = await this.getMarketRate(SATS_PER_BTC);
-    return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
-  }
-  async requestRelease(args) {
-    const client = await this.client;
-    const {
-      lock,
-      releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
-      argonKeyring,
-      tip,
-      txProgressCallback
-    } = args;
-    if (!toScriptPubkey.startsWith("0x")) {
-      throw new Error("toScriptPubkey must be a hex string starting with 0x");
-    }
-    const submitter = new TxSubmitter(
-      client,
-      client.tx.bitcoinLocks.requestRelease(lock.utxoId, toScriptPubkey, bitcoinNetworkFee),
-      argonKeyring
-    );
-    let redemptionPrice = await this.getRedemptionRate(lock.satoshis);
-    if (redemptionPrice > lock.lockPrice) {
-      redemptionPrice = lock.lockPrice;
-    }
-    const canAfford = await submitter.canAfford({
-      tip,
-      unavailableBalance: BigInt(redemptionPrice)
-    });
-    if (!canAfford.canAfford) {
-      throw new Error(
-        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice)}`
-      );
-    }
-    const txResult = await submitter.submit({
-      waitForBlock: true,
-      logResults: true,
-      tip,
-      txProgressCallback
-    });
-    const blockHash = await txResult.inBlockPromise;
-    const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
-    return {
-      blockHash,
-      blockHeight
-    };
-  }
-  async releasePrice(satoshis, lockPrice) {
-    const client = await this.client;
-    const redemptionRate = await this.getRedemptionRate(satoshis);
-    if (redemptionRate > lockPrice) {
-      return redemptionRate;
-    }
-    return lockPrice;
-  }
-  async getRatchetPrice(lock, vault) {
-    const { createdAtHeight, vaultClaimHeight, lockPrice, satoshis } = lock;
-    const client = await this.client;
-    const marketRate = await this.getMarketRate(BigInt(satoshis));
-    let ratchetingFee = vault.terms.bitcoinBaseFee;
-    let burnAmount = 0n;
-    if (marketRate > lockPrice) {
-      const lockFee = vault.calculateBitcoinFee(marketRate);
-      const currentBitcoinHeight = await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
-      const blockLength = vaultClaimHeight - createdAtHeight;
-      const elapsed = (currentBitcoinHeight - createdAtHeight) / blockLength;
-      const remainingDuration = 1 - elapsed;
-      ratchetingFee = BigInt(remainingDuration * Number(lockFee));
-    } else {
-      burnAmount = await this.releasePrice(lock.satoshis, lockPrice);
-    }
-    return {
-      ratchetingFee,
-      burnAmount,
-      marketRate
-    };
-  }
-  async ratchet(args) {
-    const { lock, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
-    const client = await this.client;
-    const ratchetPrice = await this.getRatchetPrice(lock, vault);
-    const txSubmitter = new TxSubmitter(
-      client,
-      client.tx.bitcoinLocks.ratchet(lock.utxoId),
-      argonKeyring
-    );
-    const canAfford = await txSubmitter.canAfford({
-      tip,
-      unavailableBalance: BigInt(ratchetPrice.burnAmount + ratchetPrice.ratchetingFee)
-    });
-    if (!canAfford.canAfford) {
-      throw new Error(
-        `Insufficient funds to ratchet lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(
-          ratchetPrice.burnAmount + ratchetPrice.ratchetingFee
-        )}`
-      );
-    }
-    const submission = await txSubmitter.submit({
-      waitForBlock: true,
-      tip,
-      txProgressCallback
-    });
-    const ratchetEvent = submission.events.find(
-      (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
-    );
-    if (!ratchetEvent) {
-      throw new Error(`Ratchet event not found in transaction events`);
-    }
-    const blockHash = await submission.inBlockPromise;
-    const api = await client.at(blockHash);
-    const blockHeight = await api.query.system.number().then((x) => x.toNumber());
-    const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
-    const { amountBurned, newLockPrice, originalLockPrice } = ratchetEvent.data;
-    let mintAmount = newLockPrice.toBigInt();
-    if (newLockPrice > originalLockPrice) {
-      mintAmount -= originalLockPrice.toBigInt();
-    }
-    return {
-      txFee: submission.finalFee ?? 0n,
-      securityFee: ratchetPrice.ratchetingFee,
-      pendingMint: mintAmount,
-      newLockPrice: newLockPrice.toBigInt(),
-      burned: amountBurned.toBigInt(),
-      blockHeight,
-      bitcoinBlockHeight
-    };
-  }
-  static async waitForSpace(accountset, options) {
-    const { argonAmount, bitcoinXpub, maxLockFee, tip = 0n } = options;
-    const vaults = new VaultMonitor(accountset, {
-      bitcoinSpaceAvailable: argonAmount
-    });
-    const bitcoinXpubBuffer = hexToU8a2(bitcoinXpub);
-    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);
-          let satoshis = await bitcoinLock.requiredSatoshisForArgonLiquidity(amount);
-          satoshis -= options.satoshiWiggleRoomForDynamicPrice ?? 500n;
-          const { txResult, lock, securityFee } = await bitcoinLock.initializeLock({
-            vault,
-            satoshis,
-            argonKeyring: accountset.txSubmitterPair,
-            ownerBitcoinPubkey: bitcoinXpubBuffer,
-            tip
-          });
-          resolve({
-            satoshis,
-            argons: argonAmount,
-            vaultId,
-            securityFee,
-            txFee: txResult.finalFee,
-            finalizedPromise: txResult.finalizedPromise,
-            utxoId: lock.utxoId
-          });
-        } catch (err) {
-          console.error("Error submitting bitcoin lock tx:", err);
-          reject(err);
-        } finally {
-          vaults.stop();
-        }
-      });
-      await vaults.monitor();
-    });
-  }
-};
-
-// src/keyringUtils.ts
-function keyringFromSuri(suri, cryptoType = "sr25519") {
-  return new Keyring({ type: cryptoType }).createFromUri(suri);
-}
-function createKeyringPair(opts) {
-  const { cryptoType } = opts;
-  const seed = mnemonicGenerate();
-  return keyringFromSuri(seed, cryptoType);
-}
-
-// src/index.ts
-import { u8aToHex as u8aToHex4, hexToU8a as hexToU8a3, u8aEq } from "@polkadot/util";
-import { GenericEvent as GenericEvent2, GenericBlock, GenericAddress } from "@polkadot/types/generic";
-import {
-  BTreeMap,
-  Bytes,
-  Compact,
-  Enum,
-  Null,
-  Option as Option2,
-  Result,
-  Bool,
-  Tuple,
-  Range,
-  Struct,
-  Text,
-  U256,
-  U8aFixed,
-  Vec,
-  bool,
-  i128,
-  u128,
-  u16,
-  u32,
-  u64,
-  u8
-} from "@polkadot/types-codec";
-async function waitForLoad() {
-  await cryptoWaitReady();
-}
-async function getClient(host) {
-  let provider;
-  if (host.startsWith("http")) {
-    provider = new HttpProvider(host);
-  } else {
-    provider = new WsProvider(host);
-  }
-  return await ApiPromise.create({ provider, noInitWarn: true });
-}
-
-export {
-  WageProtector,
-  setConfig,
-  getConfig,
-  TxSubmitter,
-  TxResult,
-  MICROGONS_PER_ARGON,
-  miniSecretFromUri,
-  formatArgons,
-  formatPercent,
-  filterUndefined,
-  gettersToObject,
-  toFixedNumber,
-  convertNumberToFixedU128,
-  convertFixedU128ToBigNumber,
-  convertPermillToBigNumber,
-  convertNumberToPermill,
-  eventDataToJson,
-  dispatchErrorToString,
-  ExtrinsicError2 as ExtrinsicError,
-  dispatchErrorToExtrinsicError,
-  checkForExtrinsicSuccess,
-  JsonExt,
-  createNanoEvents,
-  TypedEmitter,
-  AccountRegistry,
-  getTickFromHeader,
-  getAuthorFromHeader,
-  BlockWatch,
-  FrameCalculator,
-  AccountMiners,
-  Accountset,
-  parseSubaccountRange,
-  MiningBids,
-  Vault,
-  VaultMonitor,
-  CohortBidder,
-  BidPool,
-  SATS_PER_BTC,
-  BitcoinLocks,
-  keyringFromSuri,
-  createKeyringPair,
-  Keyring,
-  decodeAddress,
-  mnemonicGenerate,
-  waitForLoad,
-  getClient,
-  u8aToHex4 as u8aToHex,
-  hexToU8a3 as hexToU8a,
-  u8aEq,
-  GenericEvent2 as GenericEvent,
-  GenericBlock,
-  GenericAddress,
-  BTreeMap,
-  Bytes,
-  Compact,
-  Enum,
-  Null,
-  Option2 as Option,
-  Result,
-  Bool,
-  Tuple,
-  Range,
-  Struct,
-  Text,
-  U256,
-  U8aFixed,
-  Vec,
-  bool,
-  i128,
-  u128,
-  u16,
-  u32,
-  u64,
-  u8
-};
-//# sourceMappingURL=chunk-PXZPYJ4P.js.map