@argonprotocol/mainchain 1.3.6 → 1.3.8

package/browser/index.js

@@ -11,12 +11,11 @@ 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 { u8aToHex, hexToU8a } from '@polkadot/util';
-export { hexToU8a, u8aEq, u8aToHex } from '@polkadot/util';
-import { printTable, Table } from 'console-table-printer';
+import * as BigNumber2 from 'bignumber.js';
+import BigNumber2__default from 'bignumber.js';
 import bs58check from 'bs58check';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+export { hexToU8a, u8aEq, u8aToHex } from '@polkadot/util';
 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';
 
@@ -79,33 +78,11 @@ var WageProtector = class _WageProtector {
   }
 };
 
-// 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]);
-  }
+  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) {
@@ -137,7 +114,7 @@ var TxSubmitter = class {
     const result = new TxResult(this.client, logResults);
     result.txProgressCallback = options.txProgressCallback;
     let toHuman = this.tx.toHuman().method;
-    let txString = [];
+    const txString = [];
     let api = formatCall(toHuman);
     const args = [];
     if (api === "proxy.proxy") {
@@ -201,10 +178,8 @@ var TxResult = class {
       this.finalizedResolve = resolve;
       this.finalizedReject = reject;
     });
-    this.inBlockPromise.catch(() => {
-    });
-    this.finalizedPromise.catch(() => {
-    });
+    this.inBlockPromise.catch(() => null);
+    this.finalizedPromise.catch(() => null);
   }
   onResult(result) {
     this.status = result.status;
@@ -254,26 +229,17 @@ var TxResult = class {
     this.finalizedReject(error);
   }
 };
-var { ROUND_FLOOR } = BigNumber;
+var { ROUND_FLOOR } = BigNumber2;
 var MICROGONS_PER_ARGON = 1e6;
 function formatArgons(microgons) {
   if (microgons === void 0 || microgons === null) return "na";
   const isNegative = microgons < 0;
-  let format = BigNumber__default(microgons.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+  let format = BigNumber2__default(microgons.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
   if (format.endsWith(".00")) {
     format = format.slice(0, -3);
   }
   return `${isNegative ? "-" : ""}\u20B3${format}`;
 }
-function formatPercent(x) {
-  if (!x) return "na";
-  return `${x.times(100).decimalPlaces(3)}%`;
-}
-function filterUndefined(obj) {
-  return Object.fromEntries(
-    Object.entries(obj).filter(([_, value]) => value !== void 0 && value !== null)
-  );
-}
 async function gettersToObject(obj) {
   if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
   const keys = [];
@@ -299,36 +265,6 @@ async function gettersToObject(obj) {
   }
   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) {
@@ -377,79 +313,18 @@ function checkForExtrinsicSuccess(events, client) {
     }
   });
 }
-var JsonExt = class {
-  static stringify(obj, space) {
-    return JSON.stringify(
-      obj,
-      (_, v) => {
-        if (typeof v === "bigint") {
-          return `${v}n`;
-        }
-        if (v instanceof Uint8Array) {
-          return {
-            type: "Buffer",
-            data: Array.from(v)
-            // Convert Uint8Array to an array of numbers
-          };
-        }
-        return v;
-      },
-      space
-    );
-  }
-  static parse(str) {
-    return JSON.parse(str, (_, v) => {
-      if (typeof v === "string" && v.match(/^\d+n$/)) {
-        return BigInt(v.slice(0, -1));
-      }
-      if (typeof v === "object" && v !== null && v.type === "Buffer" && Array.isArray(v.data)) {
-        return Uint8Array.from(v.data);
-      }
-      return v;
-    });
-  }
-};
-function createNanoEvents() {
-  return new TypedEmitter();
-}
-var TypedEmitter = class {
-  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/keyringUtils.ts
+function keyringFromSuri(suri, cryptoType = "sr25519") {
+  return new Keyring({ type: cryptoType }).createFromUri(suri);
+}
+function createKeyringPair(opts) {
+  const { cryptoType } = opts;
+  const seed = mnemonicGenerate();
+  return keyringFromSuri(seed, cryptoType);
+}
 
-// src/BlockWatch.ts
+// src/header.ts
 function getTickFromHeader(client, header) {
   for (const x of header.digest.logs) {
     if (x.isPreRuntime) {
@@ -472,845 +347,7 @@ function getAuthorFromHeader(client, header) {
   }
   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 _FrameCalculator {
-  constructor() {
-    __publicField(this, "miningConfig");
-    __publicField(this, "genesisTick");
-    __publicField(this, "tickMillis");
-  }
-  async load(client) {
-    return await this.getConfig(client);
-  }
-  async getForTick(client, tick) {
-    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
-    const ticksSinceMiningStart = tick - biddingStartTick;
-    return Math.floor(ticksSinceMiningStart / ticksBetweenFrames);
-  }
-  async getTickRangeForFrame(client, frameId) {
-    const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
-    return _FrameCalculator.calculateTickRangeForFrame(frameId, {
-      ticksBetweenFrames,
-      biddingStartTick
-    });
-  }
-  async getForHeader(client, header) {
-    if (header.number.toNumber() === 0) return 0;
-    const tick = getTickFromHeader(client, header);
-    if (tick === void 0) return void 0;
-    return this.getForTick(client, tick);
-  }
-  static frameToDateRange(frameId, config2) {
-    const [start, end] = _FrameCalculator.calculateTickRangeForFrame(frameId, config2);
-    return [new Date(start * config2.tickMillis), new Date(end * config2.tickMillis)];
-  }
-  static calculateTickRangeForFrame(frameId, config2) {
-    const { ticksBetweenFrames, biddingStartTick } = config2;
-    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
-    const endingTick = startingTick + ticksBetweenFrames - 1;
-    return [startingTick, endingTick];
-  }
-  async getConfig(client) {
-    this.miningConfig ?? (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()));
-    this.tickMillis ?? (this.tickMillis = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()));
-    const config2 = this.miningConfig;
-    const genesisTick = this.genesisTick;
-    return {
-      ticksBetweenFrames: config2.ticksBetweenSlots,
-      slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
-      genesisTick,
-      tickMillis: this.tickMillis,
-      biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
-    };
-  }
-};
-
-// src/AccountMiners.ts
-var AccountMiners = class _AccountMiners {
-  constructor(accountset, registeredMiners, options = { shouldLog: false }) {
-    this.accountset = accountset;
-    this.options = options;
-    __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 { ROUND_FLOOR: ROUND_FLOOR2 } = BigNumber2;
 var Vault = class _Vault {
   constructor(id, vault, tickDuration) {
     this.tickDuration = tickDuration;
@@ -1335,8 +372,9 @@ var Vault = class _Vault {
   }
   load(vault) {
     this.securitization = vault.securitization.toBigInt();
-    this.securitizationRatio = convertFixedU128ToBigNumber(
-      vault.securitizationRatio.toBigInt()
+    this.securitizationRatio = fromFixedNumber(
+      vault.securitizationRatio.toBigInt(),
+      FIXED_U128_DECIMALS
     ).toNumber();
     this.argonsLocked = vault.argonsLocked.toBigInt();
     this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
@@ -1347,12 +385,14 @@ var Vault = class _Vault {
       }
     }
     this.terms = {
-      bitcoinAnnualPercentRate: convertFixedU128ToBigNumber(
-        vault.terms.bitcoinAnnualPercentRate.toBigInt()
+      bitcoinAnnualPercentRate: fromFixedNumber(
+        vault.terms.bitcoinAnnualPercentRate.toBigInt(),
+        FIXED_U128_DECIMALS
       ),
       bitcoinBaseFee: vault.terms.bitcoinBaseFee.toBigInt(),
-      liquidityPoolProfitSharing: convertPermillToBigNumber(
-        vault.terms.liquidityPoolProfitSharing.toBigInt()
+      liquidityPoolProfitSharing: fromFixedNumber(
+        vault.terms.liquidityPoolProfitSharing.toBigInt(),
+        PERMILL_DECIMALS
       )
     };
     this.operatorAccountId = vault.operatorAccountId.toString();
@@ -1361,12 +401,14 @@ var Vault = class _Vault {
       const [tickApply, terms] = vault.pendingTerms.value;
       this.pendingTermsChangeTick = tickApply.toNumber();
       this.pendingTerms = {
-        bitcoinAnnualPercentRate: convertFixedU128ToBigNumber(
-          terms.bitcoinAnnualPercentRate.toBigInt()
+        bitcoinAnnualPercentRate: fromFixedNumber(
+          terms.bitcoinAnnualPercentRate.toBigInt(),
+          FIXED_U128_DECIMALS
         ),
         bitcoinBaseFee: terms.bitcoinBaseFee.toBigInt(),
-        liquidityPoolProfitSharing: convertPermillToBigNumber(
-          vault.terms.liquidityPoolProfitSharing.toBigInt()
+        liquidityPoolProfitSharing: fromFixedNumber(
+          vault.terms.liquidityPoolProfitSharing.toBigInt(),
+          PERMILL_DECIMALS
         )
       };
     }
@@ -1380,20 +422,20 @@ var Vault = class _Vault {
     return [...this.argonsScheduledForRelease.values()].reduce((acc, val) => acc + val, 0n);
   }
   securitizationRatioBN() {
-    return new BigNumber__default(this.securitizationRatio);
+    return new BigNumber2__default(this.securitizationRatio);
   }
   recoverySecuritization() {
-    const reserved = new BigNumber__default(1).div(this.securitizationRatioBN());
+    const reserved = new BigNumber2__default(1).div(this.securitizationRatioBN());
     return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
   }
   minimumSecuritization() {
     return BigInt(
-      this.securitizationRatioBN().multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber__default.ROUND_CEIL).toString()
+      this.securitizationRatioBN().multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber2__default.ROUND_CEIL).toString()
     );
   }
   activatedSecuritization() {
     const activated = this.argonsLocked - this.argonsPendingActivation;
-    const maxRatio = BigNumber__default(Math.min(this.securitizationRatio, 2));
+    const maxRatio = BigNumber2__default(Math.min(this.securitizationRatio, 2));
     return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
   }
   /**
@@ -1404,7 +446,7 @@ var Vault = class _Vault {
     return activated / 10n;
   }
   calculateBitcoinFee(amount) {
-    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber__default.ROUND_CEIL);
+    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber2__default.ROUND_CEIL);
     return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
   }
   static async get(client, vaultId, tickDurationMillis) {
@@ -1415,7 +457,7 @@ var Vault = class _Vault {
     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 = {}) {
+  static async create(client, keypair, args, config = {}) {
     const {
       securitization,
       securitizationRatio,
@@ -1436,18 +478,21 @@ var Vault = class _Vault {
         xpubBytes = bytes;
       }
     }
-    let vaultParams = {
+    const vaultParams = {
       terms: {
         // convert to fixed u128
-        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
+        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, FIXED_U128_DECIMALS),
         bitcoinBaseFee: BigInt(baseFee),
-        liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
+        liquidityPoolProfitSharing: toFixedNumber(
+          args.liquidityPoolProfitSharing,
+          PERMILL_DECIMALS
+        )
       },
-      securitizationRatio: toFixedNumber(securitizationRatio, 18),
+      securitizationRatio: toFixedNumber(securitizationRatio, FIXED_U128_DECIMALS),
       securitization: BigInt(securitization),
       bitcoinXpubkey: xpubBytes
     };
-    let tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
+    const tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
     if (doNotExceedBalance) {
       const finalTip = tip ?? 0n;
       let txFee = await tx.feeEstimate(finalTip);
@@ -1484,880 +529,39 @@ var Vault = class _Vault {
     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 tickDuration = config.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}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, callbacks) {
-    this.accountset = accountset;
-    this.cohortStartingFrameId = cohortStartingFrameId;
-    this.subaccounts = subaccounts;
-    this.options = options;
-    this.callbacks = callbacks;
-    __publicField(this, "txFees", 0n);
-    __publicField(this, "bidsAttempted", 0);
-    __publicField(this, "winningBids", []);
-    __publicField(this, "myAddresses", /* @__PURE__ */ new Set());
-    __publicField(this, "currentBids", {
-      bids: [],
-      mostRecentBidTick: 0,
-      atTick: 0,
-      atBlockNumber: 0
-    });
-    __publicField(this, "unsubscribe");
-    __publicField(this, "pendingRequest");
-    __publicField(this, "isStopped", false);
-    __publicField(this, "millisPerTick");
-    __publicField(this, "minIncrement", 10000n);
-    __publicField(this, "nextCohortSize");
-    __publicField(this, "lastBidTick", 0);
-    __publicField(this, "evaluateInterval");
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  get clientPromise() {
-    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.clientPromise;
-    this.minIncrement = client.consts.miningSlot.bidIncrements.toBigInt();
-    this.nextCohortSize = await client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
-    if (this.subaccounts.length > this.nextCohortSize) {
-      console.info(
-        `Cohort size ${this.nextCohortSize} is less than provided subaccounts ${this.subaccounts.length}.`
-      );
-      this.subaccounts.length = this.nextCohortSize;
-    }
-    this.millisPerTick = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    let didStart = false;
-    this.unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.bidsForNextSlotCohort,
-        client.query.miningSlot.nextFrameId,
-        client.query.ticks.currentTick,
-        client.query.system.number
-      ],
-      async ([rawBids, nextFrameId, currentTick, blockNumber]) => {
-        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
-          this.updateBidList(rawBids, blockNumber.toNumber(), currentTick.toNumber());
-          if (!didStart) {
-            didStart = true;
-            this.scheduleEvaluation();
-            void this.checkWinningBids();
-          }
-        }
-      }
-    );
-  }
-  async stop() {
-    if (this.isStopped) return this.winningBids;
-    this.isStopped = true;
-    clearInterval(this.evaluateInterval);
-    console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
-    if (this.unsubscribe) {
-      this.unsubscribe();
-    }
-    const client = await this.clientPromise;
-    const [nextFrameId, isBiddingOpen] = await client.queryMulti([
-      client.query.miningSlot.nextFrameId,
-      client.query.miningSlot.isNextSlotBiddingOpen
-    ]);
-    if (nextFrameId.toNumber() === this.cohortStartingFrameId && isBiddingOpen.isTrue) {
-      console.log("Bidding is still open, waiting for it to close");
-      await new Promise(async (resolve) => {
-        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen((isOpen) => {
-          if (isOpen.isFalse) {
-            unsub();
-            resolve();
-          }
-        });
-      });
-    }
-    void await this.pendingRequest;
-    const currentFrameId = await client.query.miningSlot.nextFrameId();
-    let blockNumber;
-    if (currentFrameId.toNumber() > this.cohortStartingFrameId) {
-      blockNumber = await client.query.miningSlot.frameStartBlockNumbers().then((x) => x[0]?.toNumber()) - 1;
-    } else {
-      blockNumber = await client.query.system.number().then((x) => x.toNumber());
-    }
-    const blockHash = await client.query.system.blockHash(blockNumber);
-    const api = await client.at(blockHash);
-    const rawBids = await api.query.miningSlot.bidsForNextSlotCohort();
-    const currentTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    this.updateBidList(rawBids, blockNumber, currentTick);
-    console.log("Bidder stopped", {
-      cohortStartingFrameId: this.cohortStartingFrameId,
-      blockNumber,
-      winningBids: this.winningBids
-    });
-    return this.winningBids;
-  }
-  async checkWinningBids() {
-    if (this.isStopped) return;
-    if (this.pendingRequest) {
-      console.log("Current bid is still in progress, skipping this check");
-      return;
-    }
-    if (this.currentBids.mostRecentBidTick < this.lastBidTick) {
-      console.log(`Waiting for bids more recent than our last attempt.`, {
-        ownAttemptedBidTick: this.lastBidTick,
-        liveBidsTick: this.currentBids.mostRecentBidTick
-      });
-      return;
-    }
-    const bids = [...this.currentBids.bids];
-    const bidsAtTick = this.currentBids.atTick;
-    const blockNumber = this.currentBids.atBlockNumber;
-    const winningBids = bids.filter((x) => this.myAddresses.has(x.address));
-    if (winningBids.length >= this.subaccounts.length) {
-      console.log(`No updates needed. Winning all remaining seats (${winningBids.length}).`);
-      return;
-    }
-    console.log(
-      `Checking bids for cohort ${this.cohortStartingFrameId}, Still trying for seats: ${this.subaccounts.length}`
-    );
-    const winningAddresses = new Set(winningBids.map((x) => x.address));
-    let lowestBid;
-    let myAllocatedBids = 0n;
-    for (const bid of bids) {
-      lowestBid ?? (lowestBid = bid.bidMicrogons);
-      if (this.myAddresses.has(bid.address)) {
-        myAllocatedBids += bid.bidMicrogons;
-      } else {
-        if (bid.bidMicrogons < lowestBid) {
-          lowestBid = bid.bidMicrogons;
-        }
-      }
-    }
-    lowestBid ?? (lowestBid = -this.options.bidIncrement);
-    let nextBid = lowestBid + this.options.bidIncrement;
-    if (nextBid < this.options.minBid) {
-      nextBid = this.options.minBid;
-    }
-    if (nextBid > this.options.maxBid) {
-      nextBid = this.options.maxBid;
-    }
-    const fakeTx = await this.accountset.createMiningBidTx({
-      subaccounts: this.subaccounts,
-      bidAmount: nextBid
-    });
-    let availableBalanceForBids = await this.accountset.submitterBalance();
-    availableBalanceForBids += myAllocatedBids;
-    const tip = this.options.tipPerTransaction ?? 0n;
-    const feeEstimate = await fakeTx.feeEstimate(tip);
-    const estimatedFeePlusTip = feeEstimate + tip;
-    let budgetForSeats = this.options.maxBudget - estimatedFeePlusTip;
-    if (budgetForSeats > availableBalanceForBids) {
-      budgetForSeats = availableBalanceForBids - estimatedFeePlusTip;
-    }
-    if (nextBid < lowestBid) {
-      console.log(
-        `Next bid within parameters is ${formatArgons(nextBid)}, but it's not enough. Current lowest bid is ${formatArgons(lowestBid)}.`
-      );
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: 0,
-        winningBidCount: winningBids.length,
-        reason: "max-bid-too-low",
-        availableBalanceForBids
-      });
-      return;
-    }
-    if (nextBid - lowestBid < Number(this.minIncrement)) {
-      console.log(
-        `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints (next bid below min increment).`,
-        {
-          lowestCurrentBid: formatArgons(lowestBid),
-          nextAttemptedBid: formatArgons(nextBid),
-          maxBid: formatArgons(this.options.maxBid)
-        }
-      );
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: 0,
-        winningBidCount: winningBids.length,
-        reason: "max-bid-too-low",
-        availableBalanceForBids
-      });
-      return;
-    }
-    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
-    let accountsToUse = [...this.subaccounts];
-    if (accountsToUse.length > seatsInBudget) {
-      this.safeRecordParamsAdjusted({
-        tick: bidsAtTick,
-        blockNumber,
-        maxSeats: this.subaccounts.length,
-        winningBidCount: winningBids.length,
-        reason: availableBalanceForBids - estimatedFeePlusTip < nextBid * BigInt(seatsInBudget) ? "insufficient-balance" : "max-budget-too-low",
-        availableBalanceForBids
-      });
-      accountsToUse.sort((a, b) => {
-        const isWinningA = winningAddresses.has(a.address);
-        const isWinningB = winningAddresses.has(b.address);
-        if (isWinningA && !isWinningB) return -1;
-        if (!isWinningA && isWinningB) return 1;
-        if (a.isRebid && !b.isRebid) return -1;
-        if (!a.isRebid && b.isRebid) return 1;
-        return a.index - b.index;
-      });
-      accountsToUse.length = seatsInBudget;
-    }
-    if (accountsToUse.length > winningBids.length) {
-      this.pendingRequest = this.submitBids(nextBid, accountsToUse);
-    }
-  }
-  async submitBids(microgonsPerSeat, subaccounts) {
-    try {
-      this.bidsAttempted += subaccounts.length;
-      const submitter = await this.accountset.createMiningBidTx({
-        subaccounts,
-        bidAmount: microgonsPerSeat
-      });
-      const tip = this.options.tipPerTransaction ?? 0n;
-      const txResult = await submitter.submit({
-        tip,
-        useLatestNonce: true
-      });
-      const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
-      const client = await this.clientPromise;
-      let api = txResult.includedInBlock ? await client.at(txResult.includedInBlock) : client;
-      this.lastBidTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-      const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-      const bidAtTick = this.lastBidTick;
-      try {
-        this.callbacks?.onBidsSubmitted?.({
-          tick: bidAtTick,
-          blockNumber,
-          microgonsPerSeat,
-          txFeePlusTip: txResult.finalFee ?? 0n,
-          submittedCount: subaccounts.length
-        });
-      } catch (error) {
-        console.error("Error in onBidsSubmitted callback:", error);
-      }
-      const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
-      this.txFees += txResult.finalFee ?? 0n;
-      console.log("Result of bids for cohort", {
-        successfulBids,
-        bidsPlaced: subaccounts.length,
-        bidPerSeat: formatArgons(microgonsPerSeat),
-        bidAtTick
-      });
-      if (bidError) {
-        try {
-          this.callbacks?.onBidsRejected?.({
-            tick: bidAtTick,
-            blockNumber,
-            microgonsPerSeat,
-            submittedCount: subaccounts.length,
-            rejectedCount: subaccounts.length - successfulBids,
-            bidError
-          });
-        } catch (error) {
-          console.error("Error in onBidsRejected callback:", error);
-        }
-        throw bidError;
-      }
-    } catch (err) {
-      console.error(`Error bidding for cohort ${this.cohortStartingFrameId}:`, err);
-    } finally {
-      this.pendingRequest = void 0;
-      this.scheduleEvaluation();
-    }
-  }
-  scheduleEvaluation() {
-    const millisPerTick = this.millisPerTick;
-    const delayTicks = Math.max(this.options.bidDelay, 1);
-    const delay = delayTicks * millisPerTick;
-    if (this.evaluateInterval) clearInterval(this.evaluateInterval);
-    console.log(`Scheduling next evaluation in ${delay}ms`);
-    this.evaluateInterval = setInterval(() => this.checkWinningBids().catch(console.error), delay);
-  }
-  updateBidList(rawBids, blockNumber, tick) {
-    try {
-      let mostRecentBidTick = 0;
-      let hasDiffs = this.currentBids.bids.length !== rawBids.length;
-      const bids = [];
-      for (let i = 0; i < rawBids.length; i += 1) {
-        const rawBid = rawBids[i];
-        const bidAtTick = rawBid.bidAtTick.toNumber();
-        if (bidAtTick > mostRecentBidTick) {
-          mostRecentBidTick = bidAtTick;
-        }
-        const address = rawBid.accountId.toHuman();
-        const bidMicrogons = rawBid.bid.toBigInt();
-        if (!hasDiffs) {
-          const existing = this.currentBids.bids[i];
-          hasDiffs = existing?.address !== address || existing?.bidMicrogons !== bidMicrogons;
-        }
-        bids.push({
-          address,
-          bidMicrogons,
-          bidAtTick
-        });
-      }
-      if (blockNumber > this.currentBids.atBlockNumber && hasDiffs) {
-        this.currentBids.bids = bids;
-        this.currentBids.mostRecentBidTick = mostRecentBidTick;
-        this.currentBids.atTick = tick;
-        this.currentBids.atBlockNumber = blockNumber;
-        this.winningBids = bids.filter((x) => this.myAddresses.has(x.address));
-        console.log("Now winning bids:", this.winningBids.length);
-        if (this.callbacks?.onBidsUpdated) {
-          this.callbacks.onBidsUpdated({
-            bids: this.winningBids,
-            atBlockNumber: blockNumber,
-            tick: mostRecentBidTick
-          });
-        }
-      }
-    } catch (err) {
-      console.error("Error processing updated bids list:", err);
-    }
-  }
-  safeRecordParamsAdjusted(args) {
-    try {
-      this.callbacks?.onBidParamsAdjusted?.(args);
-    } catch (err) {
-      console.error("Error in onBidParamsAdjusted callback:", err);
-    }
-  }
-};
-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
-      });
-    }
-  }
-};
+function toFixedNumber(value, decimals) {
+  const factor = new BigNumber2__default(10).pow(decimals);
+  const bn = new BigNumber2__default(value);
+  const int = bn.times(factor).integerValue(BigNumber2__default.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
+}
+function fromFixedNumber(value, decimals = FIXED_U128_DECIMALS) {
+  const factor = new BigNumber2__default(10).pow(decimals);
+  const bn = new BigNumber2__default(value.toString());
+  return bn.div(factor);
+}
+var FIXED_U128_DECIMALS = 18;
+var PERMILL_DECIMALS = 6;
 var SATS_PER_BTC = 100000000n;
-var BitcoinLocks = class _BitcoinLocks {
+var BitcoinLocks = class {
   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)) {
+      if (this.client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
         return event.data.utxoId.toNumber();
       }
     }
     return void 0;
   }
   async getMarketRate(satoshis) {
-    const client = await this.client;
+    const client = 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);
@@ -2367,7 +571,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return rate.value.toBigInt();
   }
   async getRedemptionRate(satoshis) {
-    const client = await this.client;
+    const client = 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);
@@ -2377,7 +581,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return rate.value.toBigInt();
   }
   async getConfig() {
-    const client = await this.client;
+    const client = this.client;
     const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
     return {
       lockReleaseCosignDeadlineFrames: client.consts.bitcoinLocks.lockReleaseCosignDeadlineFrames.toNumber(),
@@ -2387,24 +591,19 @@ var BitcoinLocks = class _BitcoinLocks {
     };
   }
   async getBitcoinConfirmedBlockHeight() {
-    const client = await this.client;
-    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.value?.blockHeight.toNumber() ?? 0);
+    return await this.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.
+   * @param clientAtHeight - Optional client at the 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);
-    }
+  async getUtxoRef(utxoId, clientAtHeight) {
+    const client = clientAtHeight ?? this.client;
     const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
     if (!refRaw) {
       return;
@@ -2415,12 +614,8 @@ var BitcoinLocks = class _BitcoinLocks {
     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);
-    }
+  async getReleaseRequest(utxoId, clientAtHeight) {
+    const client = clientAtHeight ?? this.client;
     const requestMaybe = await client.query.bitcoinLocks.lockReleaseRequestsByUtxoId(utxoId);
     if (!requestMaybe.isSome) {
       return void 0;
@@ -2436,7 +631,7 @@ var BitcoinLocks = class _BitcoinLocks {
   }
   async submitVaultSignature(args) {
     const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
-    const client = await this.client;
+    const client = this.client;
     if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
       throw new Error(
         `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
@@ -2448,8 +643,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return await submitter.submit({ txProgressCallback });
   }
   async getBitcoinLock(utxoId) {
-    const client = await this.client;
-    const utxoRaw = await client.query.bitcoinLocks.locksByUtxoId(utxoId);
+    const utxoRaw = await this.client.query.bitcoinLocks.locksByUtxoId(utxoId);
     if (!utxoRaw.isSome) {
       return;
     }
@@ -2458,7 +652,8 @@ var BitcoinLocks = class _BitcoinLocks {
     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 peggedPrice = utxo.peggedPrice.toBigInt();
+    const liquidityPromised = utxo.liquidityPromised.toBigInt();
     const ownerAccount = utxo.ownerAccount.toHuman();
     const satoshis = utxo.satoshis.toBigInt();
     const vaultPubkey = utxo.vaultPubkey.toHex();
@@ -2482,7 +677,8 @@ var BitcoinLocks = class _BitcoinLocks {
       utxoId,
       p2wshScriptHashHex,
       vaultId,
-      lockPrice,
+      peggedPrice,
+      liquidityPromised,
       ownerAccount,
       satoshis,
       vaultPubkey,
@@ -2503,7 +699,7 @@ var BitcoinLocks = class _BitcoinLocks {
    * @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 client = this.client;
     const releaseHeight = await client.query.bitcoinLocks.lockReleaseCosignHeightById(utxoId);
     if (releaseHeight.isSome) {
       const releaseHeightValue = releaseHeight.unwrap().toNumber();
@@ -2538,7 +734,7 @@ var BitcoinLocks = class _BitcoinLocks {
     });
   }
   async blockHashAtHeight(atHeight) {
-    const client = await this.client;
+    const client = this.client;
     for (let i = 0; i < 10; i++) {
       const currentHeight = await client.query.system.number().then((x) => x.toNumber());
       if (atHeight > currentHeight) {
@@ -2559,7 +755,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return void 0;
   }
   async getVaultCosignSignature(utxoId, atHeight) {
-    const client = await this.client;
+    const client = this.client;
     const blockHash = await this.blockHashAtHeight(atHeight);
     if (!blockHash) {
       console.warn(`Block hash not found for height ${atHeight}`);
@@ -2577,8 +773,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return void 0;
   }
   async findPendingMints(utxoId) {
-    const client = await this.client;
-    const pendingMint = await client.query.mint.pendingMintUtxos();
+    const pendingMint = await this.client.query.mint.pendingMintUtxos();
     const mintsPending = [];
     for (const [utxoIdRaw, _accountId, mintAmountRaw] of pendingMint) {
       if (utxoIdRaw.toNumber() === utxoId) {
@@ -2589,7 +784,7 @@ var BitcoinLocks = class _BitcoinLocks {
   }
   async createInitializeLockTx(args) {
     const { vault, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
-    const client = await this.client;
+    const client = this.client;
     if (ownerBitcoinPubkey.length !== 33) {
       throw new Error(
         `Invalid Bitcoin key length: ${ownerBitcoinPubkey.length}. Must be a compressed pukey (33 bytes).`
@@ -2617,7 +812,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return { tx, securityFee, txFee };
   }
   async getBitcoinLockFromTxResult(txResult) {
-    const client = await this.client;
+    const client = this.client;
     const blockHash = await txResult.inBlockPromise;
     const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
     const utxoId = await this.getUtxoIdFromEvents(txResult.events) ?? 0;
@@ -2632,7 +827,7 @@ var BitcoinLocks = class _BitcoinLocks {
   }
   async initializeLock(args) {
     const { argonKeyring, tip = 0n, txProgressCallback } = args;
-    const client = await this.client;
+    const client = this.client;
     const { tx, securityFee } = await this.createInitializeLockTx(args);
     const submitter = new TxSubmitter(client, tx, argonKeyring);
     const txResult = await submitter.submit({
@@ -2654,7 +849,7 @@ var BitcoinLocks = class _BitcoinLocks {
     return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
   }
   async requestRelease(args) {
-    const client = await this.client;
+    const client = this.client;
     const {
       lock,
       releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
@@ -2671,8 +866,8 @@ var BitcoinLocks = class _BitcoinLocks {
       argonKeyring
     );
     let redemptionPrice = await this.getRedemptionRate(lock.satoshis);
-    if (redemptionPrice > lock.lockPrice) {
-      redemptionPrice = lock.lockPrice;
+    if (redemptionPrice > lock.peggedPrice) {
+      redemptionPrice = lock.peggedPrice;
     }
     const canAfford = await submitter.canAfford({
       tip,
@@ -2696,21 +891,20 @@ var BitcoinLocks = class _BitcoinLocks {
       blockHeight
     };
   }
-  async releasePrice(satoshis, lockPrice) {
-    await this.client;
+  async releasePrice(satoshis, peggedPrice) {
     const redemptionRate = await this.getRedemptionRate(satoshis);
-    if (redemptionRate > lockPrice) {
+    if (redemptionRate > peggedPrice) {
       return redemptionRate;
     }
-    return lockPrice;
+    return peggedPrice;
   }
   async getRatchetPrice(lock, vault) {
-    const { createdAtHeight, vaultClaimHeight, lockPrice, satoshis } = lock;
-    const client = await this.client;
+    const { createdAtHeight, vaultClaimHeight, peggedPrice, satoshis } = lock;
+    const client = this.client;
     const marketRate = await this.getMarketRate(BigInt(satoshis));
     let ratchetingFee = vault.terms.bitcoinBaseFee;
     let burnAmount = 0n;
-    if (marketRate > lockPrice) {
+    if (marketRate > peggedPrice) {
       const lockFee = vault.calculateBitcoinFee(marketRate);
       const currentBitcoinHeight = await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
       const blockLength = vaultClaimHeight - createdAtHeight;
@@ -2718,7 +912,7 @@ var BitcoinLocks = class _BitcoinLocks {
       const remainingDuration = 1 - elapsed;
       ratchetingFee = BigInt(remainingDuration * Number(lockFee));
     } else {
-      burnAmount = await this.releasePrice(lock.satoshis, lockPrice);
+      burnAmount = await this.releasePrice(lock.satoshis, peggedPrice);
     }
     return {
       ratchetingFee,
@@ -2728,7 +922,7 @@ var BitcoinLocks = class _BitcoinLocks {
   }
   async ratchet(args) {
     const { lock, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
-    const client = await this.client;
+    const client = this.client;
     const ratchetPrice = await this.getRatchetPrice(lock, vault);
     const txSubmitter = new TxSubmitter(
       client,
@@ -2761,94 +955,35 @@ var BitcoinLocks = class _BitcoinLocks {
     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();
+    const { amountBurned, newPeggedPrice, originalPeggedPrice } = ratchetEvent.data;
+    let mintAmount = newPeggedPrice.toBigInt();
+    if (newPeggedPrice > originalPeggedPrice) {
+      mintAmount -= originalPeggedPrice.toBigInt();
     }
     return {
       txFee: submission.finalFee ?? 0n,
       securityFee: ratchetPrice.ratchetingFee,
       pendingMint: mintAmount,
-      newLockPrice: newLockPrice.toBigInt(),
+      newPeggedPrice: newPeggedPrice.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) {
+async function getClient(host, options) {
   let provider;
   if (host.startsWith("http")) {
     provider = new HttpProvider(host);
   } else {
     provider = new WsProvider(host);
   }
-  return await ApiPromise.create({ provider, noInitWarn: true });
+  return await ApiPromise.create({ provider, noInitWarn: true, ...options ?? {} });
 }
 
-export { AccountMiners, AccountRegistry, Accountset, BidPool, BitcoinLocks, BlockWatch, CohortBidder, ExtrinsicError2 as ExtrinsicError, FrameCalculator, JsonExt, MICROGONS_PER_ARGON, MiningBids, SATS_PER_BTC, TxResult, 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 };
+export { BitcoinLocks, ExtrinsicError2 as ExtrinsicError, FIXED_U128_DECIMALS, MICROGONS_PER_ARGON, PERMILL_DECIMALS, SATS_PER_BTC, TxResult, TxSubmitter, Vault, WageProtector, checkForExtrinsicSuccess, createKeyringPair, dispatchErrorToExtrinsicError, dispatchErrorToString, formatArgons, fromFixedNumber, getAuthorFromHeader, getClient, getTickFromHeader, gettersToObject, keyringFromSuri, toFixedNumber, waitForLoad };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map