@argonprotocol/mainchain 1.3.1 → 1.3.3

package/browser/index.js

@@ -0,0 +1,2721 @@
+import '@polkadot/api-base/types/consts';
+import '@polkadot/api-base/types/errors';
+import '@polkadot/api-base/types/events';
+import '@polkadot/api-base/types/storage';
+import '@polkadot/api-base/types/submittable';
+import '@polkadot/rpc-core/types/jsonrpc';
+import '@polkadot/api-base/types/calls';
+import '@polkadot/types/types/registry';
+export * from '@polkadot/types/lookup';
+import { Keyring, HttpProvider, WsProvider, ApiPromise } from '@polkadot/api';
+export { Keyring } from '@polkadot/api';
+import { mnemonicGenerate, cryptoWaitReady } from '@polkadot/util-crypto';
+export { decodeAddress, mnemonicGenerate } from '@polkadot/util-crypto';
+import * as BigNumber from 'bignumber.js';
+import BigNumber__default from 'bignumber.js';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+export { hexToU8a, u8aEq, u8aToHex } from '@polkadot/util';
+import { printTable, Table } from 'console-table-printer';
+import bs58check from 'bs58check';
+export { GenericAddress, GenericBlock, GenericEvent } from '@polkadot/types/generic';
+export { BTreeMap, Bool, Bytes, Compact, Enum, Null, Option, Range, Result, Struct, Text, Tuple, U256, U8aFixed, Vec, bool, i128, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// 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),
+    keysMnemonic: config.keysMnemonic ?? 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();
+    if (unavailableBalance) {
+      availableBalance -= unavailableBalance;
+    }
+    const existentialDeposit = options.includeExistentialDeposit ? this.client.consts.balances.existentialDeposit.toBigInt() : 0n;
+    const fees = await this.feeEstimate(tip);
+    const totalCharge = fees + (tip ?? 0n);
+    const canAfford = availableBalance > totalCharge + existentialDeposit;
+    return { canAfford, availableBalance, txFee: fees };
+  }
+  async submit(options = {}) {
+    const { logResults, waitForBlock, useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
+    const result = new TxResult(this.client, logResults);
+    result.onResultCallback = options.onResultCallback;
+    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;
+    __publicField(this, "inBlockPromise");
+    __publicField(this, "finalizedPromise");
+    __publicField(this, "status");
+    __publicField(this, "events", []);
+    /**
+     * The index of the batch that was interrupted, if any.
+     */
+    __publicField(this, "batchInterruptedIndex");
+    __publicField(this, "includedInBlock");
+    /**
+     * The final fee paid for the transaction, including the fee tip.
+     */
+    __publicField(this, "finalFee");
+    /**
+     * The fee tip paid for the transaction.
+     */
+    __publicField(this, "finalFeeTip");
+    __publicField(this, "onResultCallback");
+    __publicField(this, "inBlockResolve");
+    __publicField(this, "inBlockReject");
+    __publicField(this, "finalizedResolve");
+    __publicField(this, "finalizedReject");
+    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(() => {
+    });
+  }
+  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);
+    }
+    this.onResultCallback?.(result);
+  }
+  reject(error) {
+    this.inBlockReject(error);
+    this.finalizedReject(error);
+  }
+};
+var { ROUND_FLOOR } = BigNumber;
+var MICROGONS_PER_ARGON = 1e6;
+function formatArgons(x) {
+  if (x === void 0 || x === null) return "na";
+  const isNegative = x < 0;
+  let format = BigNumber__default(x.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+  if (format.endsWith(".00")) {
+    format = format.slice(0, -3);
+  }
+  return `${isNegative ? "-" : ""}\u20B3${format}`;
+}
+function formatPercent(x) {
+  if (!x) return "na";
+  return `${x.times(100).decimalPlaces(3)}%`;
+}
+function filterUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, value]) => value !== void 0 && value !== null)
+  );
+}
+async function gettersToObject(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+  const keys = [];
+  for (const key in obj) {
+    keys.push(key);
+  }
+  if (Symbol.iterator in obj) {
+    const iterableToArray = [];
+    for (const item of obj) {
+      iterableToArray.push(await gettersToObject(item));
+    }
+    return iterableToArray;
+  }
+  const result = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      continue;
+    }
+    const value = descriptor && descriptor.get ? descriptor.get.call(obj) : obj[key];
+    if (typeof value === "function") continue;
+    result[key] = await gettersToObject(value);
+  }
+  return result;
+}
+function toFixedNumber(value, decimals) {
+  const factor = new BigNumber__default(10).pow(decimals);
+  const bn = new BigNumber__default(value);
+  const int = bn.times(factor).integerValue(BigNumber__default.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
+}
+function convertNumberToFixedU128(value) {
+  return toFixedNumber(value, 18);
+}
+function convertFixedU128ToBigNumber(fixedU128) {
+  const decimalFactor = new BigNumber__default(10).pow(new BigNumber__default(18));
+  const rawValue = new BigNumber__default(fixedU128.toString());
+  return rawValue.div(decimalFactor);
+}
+function convertPermillToBigNumber(permill) {
+  const decimalFactor = new BigNumber__default(1e6);
+  const rawValue = new BigNumber__default(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 hexToU8a(v.data);
+      }
+      return v;
+    });
+  }
+};
+function createNanoEvents() {
+  return new TypedEmitter();
+}
+var TypedEmitter = class {
+  constructor() {
+    __publicField(this, "events", {});
+  }
+  emit(event, ...args) {
+    for (const cb of this.events[event] || []) {
+      cb(...args);
+    }
+  }
+  on(event, cb) {
+    var _a;
+    ((_a = this.events)[event] || (_a[event] = [])).push(cb);
+    return () => {
+      this.events[event] = this.events[event]?.filter((i) => cb !== i);
+    };
+  }
+};
+
+// src/AccountRegistry.ts
+var _AccountRegistry = class _AccountRegistry {
+  constructor(name) {
+    __publicField(this, "namedAccounts", /* @__PURE__ */ new Map());
+    __publicField(this, "me", "me");
+    if (name) {
+      this.me = name;
+    }
+  }
+  getName(address) {
+    return this.namedAccounts.get(address);
+  }
+  register(address, name) {
+    this.namedAccounts.set(address, name);
+  }
+};
+__publicField(_AccountRegistry, "factory", (name) => new _AccountRegistry(name));
+var AccountRegistry = _AccountRegistry;
+
+// 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;
+    __publicField(this, "events", createNanoEvents());
+    __publicField(this, "locksById", {});
+    __publicField(this, "unsubscribe");
+    var _a, _b;
+    (_a = this.options).shouldLog ?? (_a.shouldLog = true);
+    (_b = this.options).finalizedBlocks ?? (_b.finalizedBlocks = false);
+  }
+  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 ?? (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 {
+  constructor() {
+    __publicField(this, "miningConfig");
+    __publicField(this, "genesisTick");
+  }
+  async getForTick(client, tick) {
+    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
+    const ticksSinceMiningStart = tick - biddingStartTick;
+    return Math.floor(ticksSinceMiningStart / ticksBetweenFrames);
+  }
+  async getTickRangeForFrame(client, frameId) {
+    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
+    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
+    const endingTick = startingTick + ticksBetweenFrames - 1;
+    return [startingTick, endingTick];
+  }
+  async getForHeader(client, header) {
+    if (header.number.toNumber() === 0) return 0;
+    const tick = getTickFromHeader(client, header);
+    if (tick === void 0) return void 0;
+    return this.getForTick(client, tick);
+  }
+  async getConfig(client) {
+    this.miningConfig ?? (this.miningConfig = await client.query.miningSlot.miningConfig().then((x) => ({
+      ticksBetweenSlots: x.ticksBetweenSlots.toNumber(),
+      slotBiddingStartAfterTicks: x.slotBiddingStartAfterTicks.toNumber()
+    })));
+    this.genesisTick ?? (this.genesisTick = await client.query.ticks.genesisTick().then((x) => x.toNumber()));
+    const config2 = this.miningConfig;
+    const genesisTick = this.genesisTick;
+    return {
+      ticksBetweenFrames: config2.ticksBetweenSlots,
+      slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
+      genesisTick,
+      biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
+    };
+  }
+};
+
+// src/AccountMiners.ts
+var AccountMiners = class _AccountMiners {
+  constructor(accountset, registeredMiners, options = { shouldLog: false }) {
+    this.accountset = accountset;
+    this.options = options;
+    __publicField(this, "events", createNanoEvents());
+    __publicField(this, "frameCalculator");
+    __publicField(this, "trackedAccountsByAddress", {});
+    this.frameCalculator = new FrameCalculator();
+    for (const miner of registeredMiners) {
+      this.trackedAccountsByAddress[miner.address] = {
+        startingFrameId: miner.seat.startingFrameId,
+        subaccountIndex: miner.subaccountIndex
+      };
+    }
+  }
+  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) {
+    var _a;
+    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[_a = entry.startingFrameId] ?? (dataByCohort[_a] = {
+              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] ?? (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
+    });
+  }
+};
+var Accountset = class {
+  constructor(options) {
+    __publicField(this, "txSubmitterPair");
+    __publicField(this, "isProxy", false);
+    __publicField(this, "seedAddress");
+    __publicField(this, "subAccountsByAddress", {});
+    __publicField(this, "accountRegistry");
+    __publicField(this, "client");
+    __publicField(this, "sessionKeyMnemonic");
+    if ("seedAccount" in options) {
+      this.txSubmitterPair = options.seedAccount;
+      this.seedAddress = options.seedAccount.address;
+      this.isProxy = false;
+    } else {
+      this.isProxy = options.isProxy;
+      this.txSubmitterPair = options.txSubmitter;
+      this.seedAddress = options.seedAddress;
+    }
+    this.sessionKeyMnemonic = options.sessionKeyMnemonic;
+    this.accountRegistry = options.accountRegistry ?? AccountRegistry.factory(options.name);
+    this.client = options.client;
+    const defaultRange = options.subaccountRange ?? getDefaultSubaccountRange();
+    this.accountRegistry.register(this.seedAddress, `${this.accountRegistry.me}//seed`);
+    for (const i of defaultRange) {
+      const pair = this.txSubmitterPair.derive(`//${i}`);
+      this.subAccountsByAddress[pair.address] = { pair, index: i };
+      this.accountRegistry.register(pair.address, `${this.accountRegistry.me}//${i}`);
+    }
+  }
+  get addresses() {
+    return [this.seedAddress, ...Object.keys(this.subAccountsByAddress)];
+  }
+  get namedAccounts() {
+    return this.accountRegistry.namedAccounts;
+  }
+  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) {
+      console.log("Looking up cohorts for frames", frameIds);
+      const cohorts = await api.query.miningSlot.minersByCohort.multi(frameIds);
+      for (let i = 0; i < frameIds.length; i++) {
+        const cohort = cohorts[i];
+        const frameId = frameIds[i];
+        bidAmountsByFrame[frameId] = cohort.map((x) => x.bid.toBigInt());
+      }
+    }
+    const addressToMiningIndex = {};
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      if (rawIndices[i].isNone) continue;
+      const [frameIdRaw, indexRaw] = rawIndices[i].value;
+      const frameId = frameIdRaw.toNumber();
+      const index = indexRaw.toNumber();
+      const bidAmount = 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 seedMnemonic = this.sessionKeyMnemonic ?? config2.keysMnemonic;
+    if (!seedMnemonic) {
+      throw new Error("KEYS_MNEMONIC environment variable not set. Cannot derive keys.");
+    }
+    const blockSealKey = `${seedMnemonic}//block-seal//${version}`;
+    const granKey = `${seedMnemonic}//grandpa//${version}`;
+    const blockSealAccount = new Keyring().createFromUri(blockSealKey, {
+      type: "ed25519"
+    });
+    const grandpaAccount = new Keyring().createFromUri(granKey, {
+      type: "ed25519"
+    });
+    return {
+      seal: {
+        privateKey: blockSealKey,
+        publicKey: u8aToHex(blockSealAccount.publicKey),
+        rawPublicKey: blockSealAccount.publicKey
+      },
+      gran: {
+        privateKey: granKey,
+        publicKey: u8aToHex(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;
+}
+var MiningBids = class {
+  constructor(client, shouldLog = true) {
+    this.client = client;
+    this.shouldLog = shouldLog;
+    __publicField(this, "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);
+    }
+  }
+};
+var { ROUND_FLOOR: ROUND_FLOOR2 } = BigNumber;
+var Vault = class _Vault {
+  constructor(id, vault, tickDuration) {
+    this.tickDuration = tickDuration;
+    __publicField(this, "securitization");
+    __publicField(this, "securitizationRatio");
+    __publicField(this, "argonsLocked");
+    __publicField(this, "argonsPendingActivation");
+    __publicField(this, "argonsScheduledForRelease", /* @__PURE__ */ new Map());
+    __publicField(this, "terms");
+    __publicField(this, "operatorAccountId");
+    __publicField(this, "isClosed");
+    __publicField(this, "vaultId");
+    __publicField(this, "pendingTerms");
+    __publicField(this, "pendingTermsChangeTick");
+    __publicField(this, "openedDate");
+    __publicField(this, "openedTick");
+    this.vaultId = id;
+    this.load(vault);
+    this.openedTick = vault.openedTick.toNumber();
+    this.openedDate = new Date(this.openedTick * this.tickDuration);
+  }
+  load(vault) {
+    this.securitization = vault.securitization.toBigInt();
+    this.securitizationRatio = convertFixedU128ToBigNumber(vault.securitizationRatio.toBigInt());
+    this.argonsLocked = vault.argonsLocked.toBigInt();
+    this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
+    if (vault.argonsScheduledForRelease.size > 0) {
+      this.argonsScheduledForRelease.clear();
+      for (const [tick, amount] of vault.argonsScheduledForRelease.entries()) {
+        this.argonsScheduledForRelease.set(tick.toNumber(), amount.toBigInt());
+      }
+    }
+    this.terms = {
+      bitcoinAnnualPercentRate: convertFixedU128ToBigNumber(
+        vault.terms.bitcoinAnnualPercentRate.toBigInt()
+      ),
+      bitcoinBaseFee: vault.terms.bitcoinBaseFee.toBigInt(),
+      liquidityPoolProfitSharing: convertPermillToBigNumber(
+        vault.terms.liquidityPoolProfitSharing.toBigInt()
+      )
+    };
+    this.operatorAccountId = vault.operatorAccountId.toString();
+    this.isClosed = vault.isClosed.valueOf();
+    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);
+  }
+  recoverySecuritization() {
+    const reserved = new BigNumber__default(1).div(this.securitizationRatio);
+    return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
+  }
+  minimumSecuritization() {
+    return BigInt(
+      this.securitizationRatio.multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber__default.ROUND_CEIL).toString()
+    );
+  }
+  activatedSecuritization() {
+    const activated = this.argonsLocked - this.argonsPendingActivation;
+    let maxRatio = this.securitizationRatio;
+    if (this.securitizationRatio.toNumber() > 2) {
+      maxRatio = BigNumber__default(2);
+    }
+    return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
+  }
+  /**
+   * Returns the amount of Argons available to match per liquidity pool
+   */
+  activatedSecuritizationPerSlot() {
+    const activated = this.activatedSecuritization();
+    return activated / 10n;
+  }
+  calculateBitcoinFee(amount) {
+    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber__default.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,
+      progressCallback
+    } = 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,
+      onResultCallback(result2) {
+        let percent = 0;
+        if (result2.status.isInvalid || result2.status.isDropped || result2.status.isUsurped || result2.status.isRetracted) {
+          percent = 1;
+        } else if (result2.status.isReady) {
+          percent = 0;
+        } else if (result2.status.isBroadcast) {
+          percent = 0.5;
+        } else if (result2.status.isInBlock) {
+          percent = 1;
+        } else if (result2.status.isFinalized) {
+          percent = 1.1;
+        }
+        progressCallback?.(percent, result2.status);
+      }
+    });
+    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 };
+  }
+};
+var VaultMonitor = class {
+  constructor(accountset, alerts = {}, options = {}) {
+    this.accountset = accountset;
+    this.alerts = alerts;
+    this.options = options;
+    __publicField(this, "events", createNanoEvents());
+    __publicField(this, "vaultsById", {});
+    __publicField(this, "blockWatch");
+    __publicField(this, "mainchain");
+    __publicField(this, "activatedCapitalByVault", {});
+    __publicField(this, "lastPrintedBids");
+    __publicField(this, "miningBids");
+    __publicField(this, "tickDuration", 0);
+    __publicField(this, "vaultOnlyWatchMode", false);
+    __publicField(this, "shouldLog", true);
+    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);
+    });
+  }
+  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) => {
+      var _a;
+      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);
+        (_a = this.activatedCapitalByVault)[id] ?? (_a[id] = 0n);
+        this.checkMiningBondAlerts(id, vault);
+      }
+    });
+    this.printVaults();
+    if (!this.vaultOnlyWatchMode && this.shouldLog) {
+      this.miningBids.print();
+    }
+    if (!justPrint) await this.blockWatch.start();
+  }
+  printVaults() {
+    if (!this.shouldLog) return;
+    const vaults = [];
+    for (const [vaultId, vault] of Object.entries(this.vaultsById)) {
+      vaults.push({
+        id: vaultId,
+        btcSpace: `${formatArgons(vault.availableBitcoinSpace())} (${formatArgons(vault.argonsPendingActivation)} pending)`,
+        btcDeal: `${formatArgons(vault.terms.bitcoinBaseFee)} + ${formatPercent(vault.terms.bitcoinAnnualPercentRate)}`,
+        securitization: `${formatArgons(vault.securitization)} at ${vault.securitizationRatio.toFormat(1)}x`,
+        securActivated: `${formatArgons(vault.activatedSecuritizationPerSlot())}/slot`,
+        liquidPoolDeal: `${formatPercent(vault.terms.liquidityPoolProfitSharing)} sharing`,
+        operator: `${this.accountset.namedAccounts.has(vault.operatorAccountId) ? ` (${this.accountset.namedAccounts.get(vault.operatorAccountId)})` : vault.operatorAccountId}`,
+        state: vault.isClosed ? "closed" : vault.openedDate < /* @__PURE__ */ new Date() ? "open" : "pending"
+      });
+    }
+    if (vaults.length) {
+      if (this.vaultOnlyWatchMode) {
+        console.clear();
+      }
+      console.log("\n\nVaults:");
+      printTable(vaults);
+    }
+  }
+  async recheckAfterActive(vaultId) {
+    const activationDate = this.vaultsById[vaultId].openedDate;
+    if (this.shouldLog) {
+      console.log(`Waiting for vault ${vaultId} to activate ${activationDate}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, activationDate.getTime() - Date.now()));
+    const client = await this.mainchain;
+    let isReady = false;
+    while (!isReady) {
+      const rawVault = await client.query.vaults.vaultsById(vaultId);
+      if (!rawVault.isSome) return;
+      const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
+      this.vaultsById[vaultId] = vault;
+      if (vault.isClosed) return;
+      if (vault.openedDate < /* @__PURE__ */ new Date()) {
+        isReady = true;
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    this.checkAlerts(vaultId, this.vaultsById[vaultId]);
+  }
+  async onVaultsUpdated(blockHash, vaultIds) {
+    await this.reloadVaultsAt([...vaultIds], blockHash).catch((err) => {
+      console.error(`Failed to reload vault ${[...vaultIds]} at block ${blockHash}:`, err);
+    });
+    this.printVaults();
+  }
+  async reloadVaultsAt(vaultIds, blockHash) {
+    const client = await this.mainchain;
+    const api = await client.at(blockHash);
+    const vaults = await api.query.vaults.vaultsById.multi(vaultIds);
+    for (let i = 0; i < vaultIds.length; i += 1) {
+      this.updateVault(vaultIds[i], vaults[i]);
+    }
+  }
+  updateVault(vaultId, rawVault) {
+    if (rawVault.isNone) return;
+    const vault = new Vault(vaultId, rawVault.value, this.tickDuration);
+    this.vaultsById[vaultId] = vault;
+    if (vault.openedDate > /* @__PURE__ */ new Date()) {
+      void this.recheckAfterActive(vaultId);
+    } else {
+      this.checkAlerts(vaultId, vault);
+    }
+  }
+  checkAlerts(vaultId, vault) {
+    if (this.alerts.bitcoinSpaceAvailable !== void 0) {
+      const availableBitcoinSpace = vault.availableBitcoinSpace();
+      if (availableBitcoinSpace >= this.alerts.bitcoinSpaceAvailable) {
+        console.warn(
+          `Vault ${vaultId} has available bitcoins above ${formatArgons(this.alerts.bitcoinSpaceAvailable)}`
+        );
+        this.events.emit("bitcoin-space-above", vaultId, availableBitcoinSpace);
+      }
+    }
+  }
+  checkMiningBondAlerts(vaultId, vault) {
+    if (this.alerts.liquidityPoolSpaceAvailable === void 0) return;
+    const activatedSecuritization = vault.activatedSecuritizationPerSlot();
+    const capitalization = this.activatedCapitalByVault[vaultId] ?? 0n;
+    const available = activatedSecuritization - capitalization;
+    if (available >= this.alerts.liquidityPoolSpaceAvailable) {
+      this.events.emit("liquidity-pool-space-above", vaultId, available);
+    }
+  }
+  printBids(blockHash) {
+    if (!this.shouldLog) return;
+    if (this.lastPrintedBids === blockHash) return;
+    this.miningBids.print();
+    this.lastPrintedBids = blockHash;
+  }
+};
+
+// src/CohortBidder.ts
+var CohortBidder = class {
+  constructor(accountset, cohortStartingFrameId, subaccounts, options) {
+    this.accountset = accountset;
+    this.cohortStartingFrameId = cohortStartingFrameId;
+    this.subaccounts = subaccounts;
+    this.options = options;
+    __publicField(this, "txFees", 0n);
+    __publicField(this, "winningBids", []);
+    __publicField(this, "unsubscribe");
+    __publicField(this, "pendingRequest");
+    __publicField(this, "retryTimeout");
+    __publicField(this, "isStopped", false);
+    __publicField(this, "needsRebid", false);
+    __publicField(this, "lastBidTime", 0);
+    __publicField(this, "millisPerTick");
+    __publicField(this, "minIncrement", 10000n);
+    __publicField(this, "nextCohortSize");
+    __publicField(this, "lastBidBlockNumber", 0);
+    __publicField(this, "myAddresses", /* @__PURE__ */ new Set());
+    this.subaccounts.forEach((x) => {
+      this.myAddresses.add(x.address);
+    });
+  }
+  get client() {
+    return this.accountset.client;
+  }
+  async start() {
+    console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
+      maxBid: formatArgons(this.options.maxBid),
+      minBid: formatArgons(this.options.minBid),
+      bidIncrement: formatArgons(this.options.bidIncrement),
+      maxBudget: formatArgons(this.options.maxBudget),
+      bidDelay: this.options.bidDelay,
+      subaccounts: this.subaccounts
+    });
+    const client = await this.client;
+    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());
+    this.unsubscribe = await client.queryMulti(
+      [
+        client.query.miningSlot.bidsForNextSlotCohort,
+        client.query.miningSlot.nextFrameId
+      ],
+      async ([bids, nextFrameId]) => {
+        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
+          await this.checkWinningBids(bids);
+        }
+      }
+    );
+  }
+  async stop() {
+    if (this.isStopped) return this.winningBids;
+    this.isStopped = true;
+    console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
+    clearTimeout(this.retryTimeout);
+    if (this.unsubscribe) {
+      this.unsubscribe();
+    }
+    const client = await this.client;
+    const [nextFrameId, isBiddingOpen] = await client.queryMulti([
+      client.query.miningSlot.nextFrameId,
+      client.query.miningSlot.isNextSlotBiddingOpen
+    ]);
+    if (nextFrameId.toNumber() === this.cohortStartingFrameId && isBiddingOpen.isTrue) {
+      console.log("Bidding is still open, waiting for it to close");
+      await new Promise(async (resolve) => {
+        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen((isOpen) => {
+          if (isOpen.isFalse) {
+            unsub();
+            resolve();
+          }
+        });
+      });
+    }
+    void await this.pendingRequest;
+    let header = await client.rpc.chain.getHeader();
+    let api = await client.at(header.hash);
+    while (true) {
+      const cohortStartingFrameId = await api.query.miningSlot.nextFrameId();
+      if (cohortStartingFrameId.toNumber() === this.cohortStartingFrameId) {
+        break;
+      }
+      header = await client.rpc.chain.getHeader(header.parentHash);
+      api = await client.at(header.hash);
+    }
+    const bids = await api.query.miningSlot.bidsForNextSlotCohort();
+    this.updateSeatsWon(bids);
+    console.log("Bidder stopped", {
+      cohortStartingFrameId: this.cohortStartingFrameId,
+      blockNumber: header.number.toNumber(),
+      bids: this.winningBids
+    });
+    return this.winningBids;
+  }
+  async checkWinningBids(bids) {
+    if (this.isStopped) return;
+    clearTimeout(this.retryTimeout);
+    this.updateSeatsWon(bids);
+    const winningBids = this.winningBids.length;
+    this.needsRebid = winningBids < this.subaccounts.length;
+    const client = await this.client;
+    const bestBlock = await client.rpc.chain.getBlockHash();
+    const api = await client.at(bestBlock);
+    const blockNumber = await api.query.system.number().then((x) => x.toNumber());
+    if (this.lastBidBlockNumber >= blockNumber) return;
+    if (this.pendingRequest) return;
+    const ticksSinceLastBid = Math.floor((Date.now() - this.lastBidTime) / this.millisPerTick);
+    if (ticksSinceLastBid < this.options.bidDelay && this.needsRebid) {
+      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), this.millisPerTick);
+      return;
+    }
+    if (!this.needsRebid) return;
+    console.log(
+      "Checking bids for cohort",
+      this.cohortStartingFrameId,
+      this.subaccounts.map((x) => x.index)
+    );
+    const winningAddresses = new Set(bids.map((x) => x.accountId.toHuman()));
+    let lowestBid = -this.options.bidIncrement;
+    if (bids.length) {
+      for (let i = bids.length - 1; i >= 0; i--) {
+        if (!this.myAddresses.has(bids[i].accountId.toHuman())) {
+          lowestBid = bids.at(i).bid.toBigInt();
+          break;
+        }
+      }
+    }
+    let nextBid = lowestBid + this.options.bidIncrement;
+    if (nextBid < this.options.minBid) {
+      nextBid = this.options.minBid;
+    }
+    if (nextBid > this.options.maxBid) {
+      nextBid = this.options.maxBid;
+    }
+    const fakeTx = await this.accountset.createMiningBidTx({
+      subaccounts: this.subaccounts,
+      bidAmount: nextBid
+    });
+    let availableBalanceForBids = await api.query.system.account(this.accountset.txSubmitterPair.address).then((x) => x.data.free.toBigInt());
+    for (const bid of bids) {
+      if (this.myAddresses.has(bid.accountId.toHuman())) {
+        availableBalanceForBids += bid.bid.toBigInt();
+      }
+    }
+    const tip = this.options.tipPerTransaction ?? 0n;
+    const feeEstimate = await fakeTx.feeEstimate(tip);
+    const feePlusTip = feeEstimate + tip;
+    let budgetForSeats = this.options.maxBudget - feePlusTip;
+    if (budgetForSeats > availableBalanceForBids) {
+      budgetForSeats = availableBalanceForBids - feePlusTip;
+    }
+    if (nextBid < lowestBid) {
+      console.log(
+        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(lowestBid)}.`
+      );
+      return;
+    }
+    if (nextBid - lowestBid < Number(this.minIncrement)) {
+      console.log(
+        `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints.`,
+        {
+          lowestCurrentBid: formatArgons(lowestBid),
+          nextAttemptedBid: formatArgons(nextBid),
+          maxBid: formatArgons(this.options.maxBid)
+        }
+      );
+      return;
+    }
+    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
+    let accountsToUse = [...this.subaccounts];
+    if (accountsToUse.length > seatsInBudget) {
+      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) {
+      this.pendingRequest = this.bid(nextBid, accountsToUse);
+    }
+    this.needsRebid = false;
+  }
+  async bid(bidPerSeat, subaccounts) {
+    const prevLastBidTime = this.lastBidTime;
+    try {
+      this.lastBidTime = Date.now();
+      const submitter = await this.accountset.createMiningBidTx({
+        subaccounts,
+        bidAmount: bidPerSeat
+      });
+      const tip = this.options.tipPerTransaction ?? 0n;
+      const txResult = await submitter.submit({
+        tip,
+        useLatestNonce: true
+      });
+      const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
+      let blockNumber;
+      if (txResult.includedInBlock) {
+        const client = await this.client;
+        const api = await client.at(txResult.includedInBlock);
+        blockNumber = await api.query.system.number().then((x) => x.toNumber());
+      }
+      const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
+      this.txFees += txResult.finalFee ?? 0n;
+      if (blockNumber !== void 0) {
+        this.lastBidBlockNumber = Math.max(blockNumber, this.lastBidBlockNumber);
+      }
+      console.log("Done creating bids for cohort", {
+        successfulBids,
+        bidPerSeat,
+        blockNumber
+      });
+      if (bidError) throw bidError;
+    } catch (err) {
+      this.lastBidTime = prevLastBidTime;
+      console.error(`Error bidding for cohort ${this.cohortStartingFrameId}:`, err);
+      clearTimeout(this.retryTimeout);
+      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), 1e3);
+    } finally {
+      this.pendingRequest = void 0;
+    }
+    if (this.needsRebid) {
+      this.needsRebid = false;
+      await this.checkCurrentSeats();
+    }
+  }
+  updateSeatsWon(next) {
+    this.winningBids.length = 0;
+    for (const x of next) {
+      const bid = x.bid.toBigInt();
+      const address = x.accountId.toHuman();
+      if (this.myAddresses.has(address)) {
+        this.winningBids.push({ address, bid });
+      }
+    }
+  }
+  async checkCurrentSeats() {
+    const client = await this.client;
+    const bids = await client.query.miningSlot.bidsForNextSlotCohort();
+    await this.checkWinningBids(bids);
+  }
+};
+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;
+    __publicField(this, "bidPoolAmount", 0n);
+    __publicField(this, "nextFrameId", 1);
+    __publicField(this, "poolVaultCapitalByFrame", {});
+    __publicField(this, "vaultSecuritization", []);
+    __publicField(this, "printTimeout");
+    __publicField(this, "blockWatch");
+    __publicField(this, "vaultsById", {});
+    __publicField(this, "tickDuration");
+    __publicField(this, "lastDistributedFrameId");
+    __publicField(this, "FrameSubscriptions", {});
+    this.blockWatch = new BlockWatch(client, { shouldLog: false });
+  }
+  async onVaultsUpdated(blockHash, vaultIdSet) {
+    const client = await this.client;
+    this.tickDuration ?? (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 ?? (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) {
+    var _a, _b;
+    this.poolVaultCapitalByFrame ?? (this.poolVaultCapitalByFrame = {});
+    (_a = this.poolVaultCapitalByFrame)[frameId] ?? (_a[frameId] = {});
+    (_b = this.poolVaultCapitalByFrame[frameId])[vaultId] ?? (_b[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
+      });
+    }
+  }
+};
+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 {
+      releaseExpirationBlocks: client.consts.bitcoinLocks.lockReleaseCosignDeadlineBlocks.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 = u8aToHex(ref.txid);
+    const bitcoinTxid = u8aToHex(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 locksPendingRelease = await client.query.bitcoinLocks.locksPendingReleaseByUtxoId();
+    for (const [id, request] of locksPendingRelease.entries()) {
+      if (id.toNumber() === utxoId) {
+        return {
+          toScriptPubkey: request.toScriptPubkey.toHex(),
+          bitcoinNetworkFee: request.bitcoinNetworkFee.toBigInt(),
+          dueBlockHeight: request.cosignDueBlock.toNumber(),
+          vaultId: request.vaultId.toNumber(),
+          redemptionPrice: request.redemptionPrice.toBigInt()
+        };
+      }
+    }
+    return void 0;
+  }
+  async submitVaultSignature(args) {
+    const { utxoId, vaultSignature, argonKeyring } = 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 = u8aToHex(vaultSignature);
+    const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
+    const submitter = new TxSubmitter(client, tx, argonKeyring);
+    return await submitter.submit();
+  }
+  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 securityFee = 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 initializeLock(args) {
+    const { argonKeyring, tip = 0n } = 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 });
+    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, 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
+    } = 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 });
+    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) {
+    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 } = 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
+    });
+    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 = hexToU8a(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);
+}
+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 { AccountMiners, AccountRegistry, Accountset, BidPool, BitcoinLocks, BlockWatch, CohortBidder, ExtrinsicError2 as ExtrinsicError, FrameCalculator, JsonExt, MICROGONS_PER_ARGON, MiningBids, SATS_PER_BTC, TxSubmitter, TypedEmitter, Vault, VaultMonitor, WageProtector, checkForExtrinsicSuccess, convertFixedU128ToBigNumber, convertNumberToFixedU128, convertNumberToPermill, convertPermillToBigNumber, createKeyringPair, createNanoEvents, dispatchErrorToExtrinsicError, dispatchErrorToString, eventDataToJson, filterUndefined, formatArgons, formatPercent, getAuthorFromHeader, getClient, getConfig, getTickFromHeader, gettersToObject, keyringFromSuri, setConfig, toFixedNumber, waitForLoad };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map