@argonprotocol/mainchain 1.1.0-rc.6 → 1.1.0-rc.8

package/lib/cli.js

@@ -33,8 +33,10 @@ __export(index_exports, {
   BitcoinLocks: () => BitcoinLocks,
   BlockWatch: () => BlockWatch,
   CohortBidder: () => CohortBidder,
+  ExtrinsicError: () => ExtrinsicError2,
   JsonExt: () => JsonExt,
   Keyring: () => Keyring,
+  MICROGONS_PER_ARGON: () => MICROGONS_PER_ARGON,
   MiningBids: () => MiningBids,
   MiningRotations: () => MiningRotations,
   TxSubmitter: () => TxSubmitter,
@@ -46,6 +48,7 @@ __export(index_exports, {
   convertPermillToBigNumber: () => convertPermillToBigNumber,
   createKeyringPair: () => createKeyringPair,
   decodeAddress: () => decodeAddress,
+  dispatchErrorToExtrinsicError: () => dispatchErrorToExtrinsicError,
   dispatchErrorToString: () => dispatchErrorToString,
   eventDataToJson: () => eventDataToJson,
   filterUndefined: () => filterUndefined,
@@ -149,119 +152,6 @@ var WageProtector = class _WageProtector {
   }
 };
 
-// src/utils.ts
-import BigNumber2, * as BN from "bignumber.js";
-var { ROUND_FLOOR } = BN;
-function formatArgons(x) {
-  const isNegative = x < 0;
-  let format = BigNumber2(x.toString()).abs().div(1e6).toFormat(2, ROUND_FLOOR);
-  if (format.endsWith(".00")) {
-    format = format.slice(0, -3);
-  }
-  return `${isNegative ? "-" : ""}\u20B3${format}`;
-}
-function formatPercent(x) {
-  if (!x) return "na";
-  return `${x.times(100).decimalPlaces(3)}%`;
-}
-function filterUndefined(obj) {
-  return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([_, value]) => value !== void 0 && value !== null
-    )
-  );
-}
-async function gettersToObject(obj) {
-  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
-  const keys = [];
-  for (const key in obj) {
-    keys.push(key);
-  }
-  if (Symbol.iterator in obj) {
-    const iterableToArray = [];
-    for (const item of obj) {
-      iterableToArray.push(await gettersToObject(item));
-    }
-    return iterableToArray;
-  }
-  const result = {};
-  for (const key of keys) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-    if (descriptor && typeof descriptor.value === "function") {
-      continue;
-    }
-    const value = descriptor && descriptor.get ? descriptor.get.call(obj) : obj[key];
-    if (typeof value === "function") continue;
-    result[key] = await gettersToObject(value);
-  }
-  return result;
-}
-function convertFixedU128ToBigNumber(fixedU128) {
-  const decimalFactor = new BigNumber2(10).pow(new BigNumber2(18));
-  const rawValue = new BigNumber2(fixedU128.toString());
-  return rawValue.div(decimalFactor);
-}
-function convertPermillToBigNumber(permill) {
-  const decimalFactor = new BigNumber2(1e6);
-  const rawValue = new BigNumber2(permill.toString());
-  return rawValue.div(decimalFactor);
-}
-function eventDataToJson(event) {
-  const obj = {};
-  event.data.forEach((data, index) => {
-    const name = event.data.names?.[index];
-    obj[name ?? `${index}`] = data.toJSON();
-  });
-  return obj;
-}
-function dispatchErrorToString(client, error) {
-  let message = error.toString();
-  if (error.isModule) {
-    const decoded = client.registry.findMetaError(error.asModule);
-    const { docs, name, section } = decoded;
-    message = `${section}.${name}: ${docs.join(" ")}`;
-  }
-  return message;
-}
-function checkForExtrinsicSuccess(events, client) {
-  return new Promise((resolve, reject) => {
-    for (const { event } of events) {
-      if (client.events.system.ExtrinsicSuccess.is(event)) {
-        resolve();
-      } else if (client.events.system.ExtrinsicFailed.is(event)) {
-        const [dispatchError] = event.data;
-        let errorInfo = dispatchError.toString();
-        if (dispatchError.isModule) {
-          const decoded = client.registry.findMetaError(dispatchError.asModule);
-          errorInfo = `${decoded.section}.${decoded.name}`;
-        }
-        reject(
-          new Error(
-            `${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`
-          )
-        );
-      }
-    }
-  });
-}
-var JsonExt = class {
-  static stringify(obj, space) {
-    return JSON.stringify(
-      obj,
-      (_, v) => typeof v === "bigint" ? `${v}n` : v,
-      space
-    );
-  }
-  static parse(str) {
-    return JSON.parse(str, (_, v) => {
-      if (typeof v === "string" && v.endsWith("n")) {
-        return BigInt(v.slice(0, -1));
-      }
-      return v;
-    });
-  }
-};
-
 // src/TxSubmitter.ts
 function logExtrinsicResult(result) {
   if (process.env.DEBUG) {
@@ -393,13 +283,12 @@ var TxResult = class {
         }
       }
       if (encounteredError) {
-        const error = dispatchErrorToString(this.client, encounteredError);
-        if (batchErrorIndex) {
-          this.reject(
-            new Error(`Error in batch#${batchErrorIndex}: ${error.toString()}`)
-          );
-        }
-        this.reject(new Error(`Transaction failed: ${error}`));
+        const error = dispatchErrorToExtrinsicError(
+          this.client,
+          encounteredError,
+          batchErrorIndex
+        );
+        this.reject(error);
       } else {
         this.inBlockResolve(status.asInBlock.toU8a());
       }
@@ -414,6 +303,147 @@ var TxResult = class {
   }
 };
 
+// src/utils.ts
+import BigNumber2, * as BN from "bignumber.js";
+var { ROUND_FLOOR } = BN;
+var MICROGONS_PER_ARGON = 1e6;
+function formatArgons(x) {
+  if (x === void 0 || x === null) return "na";
+  const isNegative = x < 0;
+  let format = BigNumber2(x.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+  if (format.endsWith(".00")) {
+    format = format.slice(0, -3);
+  }
+  return `${isNegative ? "-" : ""}\u20B3${format}`;
+}
+function formatPercent(x) {
+  if (!x) return "na";
+  return `${x.times(100).decimalPlaces(3)}%`;
+}
+function filterUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(
+      ([_, value]) => value !== void 0 && value !== null
+    )
+  );
+}
+async function gettersToObject(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+  const keys = [];
+  for (const key in obj) {
+    keys.push(key);
+  }
+  if (Symbol.iterator in obj) {
+    const iterableToArray = [];
+    for (const item of obj) {
+      iterableToArray.push(await gettersToObject(item));
+    }
+    return iterableToArray;
+  }
+  const result = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      continue;
+    }
+    const value = descriptor && descriptor.get ? descriptor.get.call(obj) : obj[key];
+    if (typeof value === "function") continue;
+    result[key] = await gettersToObject(value);
+  }
+  return result;
+}
+function convertFixedU128ToBigNumber(fixedU128) {
+  const decimalFactor = new BigNumber2(10).pow(new BigNumber2(18));
+  const rawValue = new BigNumber2(fixedU128.toString());
+  return rawValue.div(decimalFactor);
+}
+function convertPermillToBigNumber(permill) {
+  const decimalFactor = new BigNumber2(1e6);
+  const rawValue = new BigNumber2(permill.toString());
+  return rawValue.div(decimalFactor);
+}
+function eventDataToJson(event) {
+  const obj = {};
+  event.data.forEach((data, index) => {
+    const name = event.data.names?.[index];
+    obj[name ?? `${index}`] = data.toJSON();
+  });
+  return obj;
+}
+function dispatchErrorToString(client, error) {
+  let message = error.toString();
+  if (error.isModule) {
+    const decoded = client.registry.findMetaError(error.asModule);
+    const { docs, name, section } = decoded;
+    message = `${section}.${name}: ${docs.join(" ")}`;
+  }
+  return message;
+}
+var ExtrinsicError2 = class extends Error {
+  constructor(errorCode, details, batchInterruptedIndex) {
+    super(errorCode);
+    this.errorCode = errorCode;
+    this.details = details;
+    this.batchInterruptedIndex = batchInterruptedIndex;
+  }
+  toString() {
+    if (this.batchInterruptedIndex !== void 0) {
+      return `${this.errorCode} ${this.details ?? ""} (Batch interrupted at index ${this.batchInterruptedIndex})`;
+    }
+    return `${this.errorCode} ${this.details ?? ""}`;
+  }
+};
+function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
+  if (error.isModule) {
+    const decoded = client.registry.findMetaError(error.asModule);
+    const { docs, name, section } = decoded;
+    return new ExtrinsicError2(
+      `${section}.${name}`,
+      docs.join(" "),
+      batchInterruptedIndex
+    );
+  }
+  return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
+}
+function checkForExtrinsicSuccess(events, client) {
+  return new Promise((resolve, reject) => {
+    for (const { event } of events) {
+      if (client.events.system.ExtrinsicSuccess.is(event)) {
+        resolve();
+      } else if (client.events.system.ExtrinsicFailed.is(event)) {
+        const [dispatchError] = event.data;
+        let errorInfo = dispatchError.toString();
+        if (dispatchError.isModule) {
+          const decoded = client.registry.findMetaError(dispatchError.asModule);
+          errorInfo = `${decoded.section}.${decoded.name}`;
+        }
+        reject(
+          new Error(
+            `${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`
+          )
+        );
+      }
+    }
+  });
+}
+var JsonExt = class {
+  static stringify(obj, space) {
+    return JSON.stringify(
+      obj,
+      (_, v) => typeof v === "bigint" ? `${v}n` : v,
+      space
+    );
+  }
+  static parse(str) {
+    return JSON.parse(str, (_, v) => {
+      if (typeof v === "string" && v.endsWith("n")) {
+        return BigInt(v.slice(0, -1));
+      }
+      return v;
+    });
+  }
+};
+
 // src/AccountRegistry.ts
 var AccountRegistry = class _AccountRegistry {
   namedAccounts = /* @__PURE__ */ new Map();
@@ -646,7 +676,7 @@ var MiningRotations = class {
     const slot1StartTick = this.genesisTick + this.miningConfig.slotBiddingStartAfterTicks + ticksBetweenSlots;
     if (tick < slot1StartTick) return 0;
     const ticksSinceSlot1 = tick - slot1StartTick;
-    return Math.floor(ticksSinceSlot1 / ticksBetweenSlots);
+    return Math.floor(ticksSinceSlot1 / ticksBetweenSlots) + 1;
   }
   async getForHeader(client, header) {
     if (header.number.toNumber() === 0) return 0;
@@ -826,6 +856,14 @@ var Accountset = class {
       );
     }
   }
+  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;
@@ -1088,18 +1126,18 @@ var Accountset = class {
     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.
+   * Create but don't submit a mining bid transaction.
+   * @param options
    */
-  async createMiningBids(options) {
-    const accounts = this.getAccountsInRange(options.subaccountRange);
+  async createMiningBidTx(options) {
     const client = await this.client;
-    let tip = options.tip ?? 0n;
+    const { bidAmount, subaccounts, sendRewardsToSeed } = options;
     const batch = client.tx.utility.batch(
-      accounts.map((x) => {
+      subaccounts.map((x) => {
         const keys = this.keys();
-        const rewards = options.sendRewardsToSeed ? { Account: this.seedAddress } : { Owner: null };
+        const rewards = sendRewardsToSeed ? { Account: this.seedAddress } : { Owner: null };
         return client.tx.miningSlot.bid(
-          options.bidAmount,
+          bidAmount,
           rewards,
           {
             grandpa: keys.gran.rawPublicKey,
@@ -1113,7 +1151,19 @@ var Accountset = class {
     if (this.isProxy) {
       tx = client.tx.proxy.proxy(this.seedAddress, "MiningBid", batch);
     }
-    const submitter = new TxSubmitter(client, tx, this.txSubmitterPair);
+    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;
@@ -1557,27 +1607,24 @@ var VaultMonitor = class {
   }
 };
 
-// src/CohortBidder.ts
-var CohortBidder = class _CohortBidder {
-  constructor(accountset, cohortId, subaccounts, options) {
-    this.accountset = accountset;
+// src/CohortBidderHistory.ts
+var CohortBidderHistory = class _CohortBidderHistory {
+  constructor(cohortId, subaccounts) {
     this.cohortId = cohortId;
     this.subaccounts = subaccounts;
-    this.options = options;
+    this.maxSeatsInPlay = this.subaccounts.length;
     this.subaccounts.forEach((x) => {
-      this.allAddresses.add(x.address);
+      this.myAddresses.add(x.address);
     });
   }
-  get client() {
-    return this.accountset.client;
-  }
+  bidHistory = [];
   stats = {
     // number of seats won
-    seats: 0,
+    seatsWon: 0,
     // sum of argons bid in successful bids
     totalArgonsBid: 0n,
     // total number of bids placed (includes 1 per seat)
-    bids: 0,
+    bidsAttempted: 0,
     // fees including the tip
     fees: 0n,
     // Max bid per seat
@@ -1589,16 +1636,157 @@ var CohortBidder = class _CohortBidder {
     // The cohort expected argons per block
     cohortArgonsPerBlock: 0n,
     // The last block that bids are synced to
-    lastBlock: 0
+    lastBlockNumber: 0
   };
+  lastBids = [];
+  myAddresses = /* @__PURE__ */ new Set();
+  maxSeatsInPlay = 0;
+  async init(client) {
+    if (!this.stats.argonotsPerSeat) {
+      const startingStats = await _CohortBidderHistory.getStartingData(client);
+      Object.assign(this.stats, startingStats);
+    }
+  }
+  maybeReducingSeats(maxSeats, reason, historyEntry) {
+    if (this.maxSeatsInPlay > maxSeats) {
+      historyEntry.maxSeatsReductionReason = reason;
+    }
+    this.maxSeatsInPlay = maxSeats;
+    historyEntry.maxSeatsInPlay = maxSeats;
+  }
+  trackChange(next, blockNumber, tick, isLastEntry = false) {
+    let winningBids = 0;
+    let totalArgonsBid = 0n;
+    const nextEntrants = [];
+    for (const x of next) {
+      const bid = x.bid.toBigInt();
+      const address = x.accountId.toHuman();
+      nextEntrants.push({ address, bid });
+      if (this.myAddresses.has(address)) {
+        winningBids++;
+        totalArgonsBid += bid;
+      }
+    }
+    this.stats.seatsWon = winningBids;
+    this.stats.totalArgonsBid = totalArgonsBid;
+    this.stats.lastBlockNumber = Math.max(
+      blockNumber,
+      this.stats.lastBlockNumber
+    );
+    const historyEntry = {
+      cohortId: this.cohortId,
+      blockNumber,
+      tick,
+      bidChanges: [],
+      winningSeats: winningBids,
+      maxSeatsInPlay: this.maxSeatsInPlay
+    };
+    const hasDiffs = JsonExt.stringify(nextEntrants) !== JsonExt.stringify(this.lastBids);
+    if (!isLastEntry || hasDiffs) {
+      this.bidHistory.unshift(historyEntry);
+    }
+    if (hasDiffs) {
+      nextEntrants.forEach(({ address, bid }, i) => {
+        const prevBidIndex = this.lastBids.findIndex(
+          (y) => y.address === address
+        );
+        const entry = {
+          address,
+          bidAmount: bid,
+          bidPosition: i,
+          prevPosition: prevBidIndex === -1 ? null : prevBidIndex
+        };
+        if (prevBidIndex !== -1) {
+          const prevBidAmount = this.lastBids[prevBidIndex].bid;
+          if (prevBidAmount !== bid) {
+            entry.prevBidAmount = prevBidAmount;
+          }
+        }
+        historyEntry.bidChanges.push(entry);
+      });
+      this.lastBids.forEach(({ address, bid }, i) => {
+        const nextBid = nextEntrants.some((y) => y.address === address);
+        if (!nextBid) {
+          historyEntry.bidChanges.push({
+            address,
+            bidAmount: bid,
+            bidPosition: null,
+            prevPosition: i
+          });
+        }
+      });
+      this.lastBids = nextEntrants;
+    }
+    return historyEntry;
+  }
+  onBidResult(historyEntry, param) {
+    const {
+      txFeePlusTip,
+      bidPerSeat,
+      bidsAttempted,
+      successfulBids,
+      blockNumber,
+      bidError
+    } = param;
+    this.stats.fees += txFeePlusTip;
+    this.stats.bidsAttempted += bidsAttempted;
+    if (bidPerSeat > this.stats.maxBidPerSeat) {
+      this.stats.maxBidPerSeat = bidPerSeat;
+    }
+    if (blockNumber !== void 0) {
+      this.stats.lastBlockNumber = Math.max(
+        blockNumber,
+        this.stats.lastBlockNumber
+      );
+    }
+    historyEntry.myBidsPlaced.failureReason = bidError;
+    historyEntry.myBidsPlaced.successfulBids = successfulBids;
+    historyEntry.myBidsPlaced.txFeePlusTip = txFeePlusTip;
+  }
+  static async getStartingData(api) {
+    const argonotPrice = await api.query.priceIndex.current();
+    let argonotUsdPrice = 0;
+    if (argonotPrice.isSome) {
+      argonotUsdPrice = convertFixedU128ToBigNumber(
+        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
+      ).toNumber();
+    }
+    const argonotsPerSeat = await api.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
+    const cohortArgonsPerBlock = await api.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
+    return { argonotsPerSeat, argonotUsdPrice, cohortArgonsPerBlock };
+  }
+};
+
+// src/CohortBidder.ts
+var CohortBidder = class {
+  constructor(accountset, cohortId, subaccounts, options) {
+    this.accountset = accountset;
+    this.cohortId = cohortId;
+    this.subaccounts = subaccounts;
+    this.options = options;
+    this.history = new CohortBidderHistory(cohortId, subaccounts);
+    this.subaccounts.forEach((x) => {
+      this.myAddresses.add(x.address);
+    });
+  }
+  get client() {
+    return this.accountset.client;
+  }
+  get stats() {
+    return this.history.stats;
+  }
+  get bidHistory() {
+    return this.history.bidHistory;
+  }
   unsubscribe;
   pendingRequest;
   retryTimeout;
   isStopped = false;
   needsRebid = false;
   lastBidTime = 0;
+  history;
   millisPerTick;
-  allAddresses = /* @__PURE__ */ new Set();
+  myAddresses = /* @__PURE__ */ new Set();
   async stop() {
     if (this.isStopped) return this.stats;
     this.isStopped = true;
@@ -1608,70 +1796,59 @@ var CohortBidder = class _CohortBidder {
       this.unsubscribe();
     }
     const client = await this.client;
-    const [nextCohort, nextCohortId, blockNumber] = await new Promise(async (resolve) => {
-      const unsub = await client.queryMulti(
-        [
-          client.query.miningSlot.nextSlotCohort,
-          client.query.miningSlot.nextCohortId,
-          client.query.miningSlot.isNextSlotBiddingOpen,
-          client.query.system.number
-        ],
-        ([nextCohort2, nextCohortId2, isBiddingStillOpen, blockNumber2]) => {
-          if (nextCohortId2.toNumber() !== this.cohortId || isBiddingStillOpen.isFalse) {
-            unsub();
-            resolve([nextCohort2, nextCohortId2, blockNumber2]);
+    const [nextCohortId, isBiddingOpen] = await client.queryMulti([
+      client.query.miningSlot.nextCohortId,
+      client.query.miningSlot.isNextSlotBiddingOpen
+    ]);
+    if (nextCohortId.toNumber() === this.cohortId && isBiddingOpen.isTrue) {
+      console.log("Bidding is still open, waiting for it to close");
+      await new Promise(async (resolve) => {
+        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen(
+          (isOpen) => {
+            if (isOpen.isFalse) {
+              unsub();
+              resolve();
+            }
           }
-        }
-      );
-    });
-    void await this.pendingRequest;
-    if (nextCohortId.toNumber() === this.cohortId) {
-      console.log("Bidder updating stats with bid queue");
-      this.updateStats(nextCohort);
-    } else {
-      const bestBlock = await client.rpc.chain.getBlockHash();
-      const api = await client.at(bestBlock);
-      const wonIndices = await api.query.miningSlot.accountIndexLookup.multi([...this.allAddresses]).then((x) => x.filter((x2) => x2.isSome).map((x2) => x2.value));
-      const wonSeats = await api.query.miningSlot.activeMinersByIndex.multi(wonIndices).then(
-        (x) => x.filter(
-          (x2) => x2.isSome && x2.value.cohortId.toNumber() === this.cohortId
-        ).map((x2) => x2.value)
-      );
-      console.log("Bidder updating stats with finalized cohort");
-      this.updateStats(wonSeats);
+        );
+      });
     }
-    this.stats.lastBlock = Math.max(
-      blockNumber.toNumber(),
-      this.stats.lastBlock
-    );
+    void await this.pendingRequest;
+    let header = await client.rpc.chain.getHeader();
+    while (true) {
+      const api2 = await client.at(header.hash);
+      const cohortId = await api2.query.miningSlot.nextCohortId();
+      if (cohortId.toNumber() === this.cohortId) {
+        break;
+      }
+      header = await client.rpc.chain.getHeader(header.parentHash);
+    }
+    const api = await client.at(header.hash);
+    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
+    const cohort = await api.query.miningSlot.nextSlotCohort();
+    this.history.trackChange(cohort, header.number.toNumber(), tick, true);
+    console.log("Bidder stopped", {
+      cohortId: this.cohortId,
+      blockNumber: header.number.toNumber(),
+      tick,
+      cohort: cohort.map((x) => ({
+        address: x.accountId.toHuman(),
+        bid: x.bid.toBigInt()
+      }))
+    });
     return this.stats;
   }
-  static async getStartingData(api) {
-    const argonotPrice = await api.query.priceIndex.current();
-    let argonotUsdPrice = 0;
-    if (argonotPrice.isSome) {
-      argonotUsdPrice = convertFixedU128ToBigNumber(
-        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
-      ).toNumber();
-    }
-    const argonotsPerSeat = await api.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
-    const cohortArgonsPerBlock = await api.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
-    return { argonotsPerSeat, argonotUsdPrice, cohortArgonsPerBlock };
-  }
   async start() {
     console.log(`Starting cohort ${this.cohortId} bidder`, {
       maxBid: formatArgons(this.options.maxBid),
       minBid: formatArgons(this.options.minBid),
       bidIncrement: formatArgons(this.options.bidIncrement),
-      maxBalance: formatArgons(this.options.maxBalance),
+      maxBudget: formatArgons(this.options.maxBudget),
       bidDelay: this.options.bidDelay,
       subaccounts: this.subaccounts
     });
     const client = await this.client;
-    if (!this.stats.argonotsPerSeat) {
-      const startingStats = await _CohortBidder.getStartingData(client);
-      Object.assign(this.stats, startingStats);
-    }
+    await this.history.init(client);
     this.millisPerTick ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
     this.unsubscribe = await client.queryMulti(
       [
@@ -1685,24 +1862,27 @@ var CohortBidder = class _CohortBidder {
       }
     );
   }
-  updateStats(next) {
-    let seats = 0;
-    let totalArgonsBid = 0n;
-    for (const x of next) {
-      if (this.allAddresses.has(x.accountId.toHuman())) {
-        seats++;
-        totalArgonsBid += x.bid.toBigInt();
-      }
-    }
-    this.stats.seats = seats;
-    this.stats.totalArgonsBid = totalArgonsBid;
-  }
   async checkSeats(next) {
-    if (this.isStopped || this.pendingRequest) return;
+    if (this.isStopped) return;
+    clearTimeout(this.retryTimeout);
+    const client = await this.client;
+    const bestBlock = await client.rpc.chain.getBlockHash();
+    const api = await client.at(bestBlock);
+    const blockNumber = await api.query.system.number().then((x) => x.toNumber());
+    if (this.bidHistory[0]?.blockNumber >= blockNumber) {
+      return;
+    }
+    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
+    const historyEntry = this.history.trackChange(next, blockNumber, tick);
+    if (this.pendingRequest) return;
     const ticksSinceLastBid = Math.floor(
       (Date.now() - this.lastBidTime) / this.millisPerTick
     );
     if (ticksSinceLastBid < this.options.bidDelay) {
+      this.retryTimeout = setTimeout(
+        () => void this.checkCurrentSeats(),
+        this.millisPerTick
+      );
       return;
     }
     console.log(
@@ -1710,12 +1890,19 @@ var CohortBidder = class _CohortBidder {
       this.cohortId,
       this.subaccounts.map((x) => x.index)
     );
-    this.updateStats(next);
-    this.needsRebid = this.subaccounts.some(
-      (x) => !next.some((y) => y.accountId.toHuman() === x.address)
-    );
+    const winningBids = historyEntry.winningSeats;
+    this.needsRebid = winningBids < this.subaccounts.length;
     if (!this.needsRebid) return;
-    const lowestBid = next.at(-1)?.bid.toBigInt() ?? -this.options.bidIncrement;
+    const winningAddresses = new Set(next.map((x) => x.accountId.toHuman()));
+    let lowestBid = -this.options.bidIncrement;
+    if (next.length) {
+      for (let i = next.length - 1; i >= 0; i--) {
+        if (!this.myAddresses.has(next[i].accountId.toHuman())) {
+          lowestBid = next.at(i).bid.toBigInt();
+          break;
+        }
+      }
+    }
     const MIN_INCREMENT = 10000n;
     let nextBid = lowestBid + this.options.bidIncrement;
     if (nextBid < this.options.minBid) {
@@ -1723,83 +1910,119 @@ var CohortBidder = class _CohortBidder {
     }
     if (nextBid > this.options.maxBid) {
       nextBid = this.options.maxBid;
-      if (nextBid - lowestBid < MIN_INCREMENT) {
-        console.log(
-          `Can't make any more bids for ${this.cohortId} with given constraints.`,
-          {
-            lowestCurrentBid: formatArgons(lowestBid),
-            nextAttemptedBid: formatArgons(nextBid),
-            maxBid: formatArgons(this.options.maxBid)
-          }
-        );
-        return;
+    }
+    const fakeTx = await this.accountset.createMiningBidTx({
+      subaccounts: this.subaccounts,
+      bidAmount: nextBid,
+      sendRewardsToSeed: true
+    });
+    let availableBalanceForBids = await api.query.system.account(this.accountset.txSubmitterPair.address).then((x) => x.data.free.toBigInt());
+    for (const bid of next) {
+      if (this.myAddresses.has(bid.accountId.toHuman())) {
+        availableBalanceForBids += bid.bid.toBigInt();
       }
     }
+    const tip = this.options.tipPerTransaction ?? 0n;
+    const feeEstimate = await fakeTx.feeEstimate(tip);
+    const feePlusTip = feeEstimate + tip;
+    let budgetForSeats = this.options.maxBudget - feePlusTip;
+    if (budgetForSeats > availableBalanceForBids) {
+      budgetForSeats = availableBalanceForBids - feePlusTip;
+    }
     if (nextBid < lowestBid) {
       console.log(
         `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(
           lowestBid
         )}.`
       );
+      this.history.maybeReducingSeats(
+        winningBids,
+        "MaxBidTooLow" /* MaxBidTooLow */,
+        historyEntry
+      );
       return;
     }
-    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(this.options.maxBalance / nextBid);
-    if (seatsInBudget <= 0) {
+    if (nextBid - lowestBid < MIN_INCREMENT) {
       console.log(
-        `Can't afford any seats at ${formatArgons(nextBid)}. Would exceed our max balance of ${formatArgons(this.options.maxBalance)}.`
+        `Can't make any more bids for ${this.cohortId} with given constraints.`,
+        {
+          lowestCurrentBid: formatArgons(lowestBid),
+          nextAttemptedBid: formatArgons(nextBid),
+          maxBid: formatArgons(this.options.maxBid)
+        }
+      );
+      this.history.maybeReducingSeats(
+        winningBids,
+        "MaxBidTooLow" /* MaxBidTooLow */,
+        historyEntry
       );
       return;
     }
-    if (this.subaccounts.length > seatsInBudget) {
-      const toKeep = [];
-      for (const account of this.subaccounts) {
-        if (toKeep.length >= seatsInBudget) break;
-        if (account.isRebid) {
-          toKeep.push(account);
-        }
-      }
-      for (const account of this.subaccounts) {
-        if (toKeep.length >= seatsInBudget) break;
-        if (!account.isRebid) {
-          toKeep.push(account);
-        }
-      }
-      const removedIndices = this.subaccounts.filter((x) => !toKeep.some((y) => y.index === x.index)).map((x) => x.index);
-      this.subaccounts = toKeep;
-      console.log("Had to remove some subaccounts to fit in budget:", {
-        removedIndices,
-        seatsInBudget,
-        budget: formatArgons(this.options.maxBalance)
+    const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
+    let accountsToUse = [...this.subaccounts];
+    if (accountsToUse.length > seatsInBudget) {
+      const reason = availableBalanceForBids - feePlusTip < nextBid * BigInt(seatsInBudget) ? "InsufficientFunds" /* InsufficientFunds */ : "MaxBudgetTooLow" /* MaxBudgetTooLow */;
+      this.history.maybeReducingSeats(seatsInBudget, reason, historyEntry);
+      accountsToUse.sort((a, b) => {
+        const isWinningA = winningAddresses.has(a.address);
+        const isWinningB = winningAddresses.has(b.address);
+        if (isWinningA && !isWinningB) return -1;
+        if (!isWinningA && isWinningB) return 1;
+        if (a.isRebid && !b.isRebid) return -1;
+        if (!a.isRebid && b.isRebid) return 1;
+        return a.index - b.index;
       });
+      accountsToUse.length = seatsInBudget;
+    }
+    if (accountsToUse.length > winningBids) {
+      historyEntry.myBidsPlaced = {
+        bids: accountsToUse.length,
+        bidPerSeat: nextBid,
+        txFeePlusTip: feePlusTip,
+        successfulBids: 0
+      };
+      this.pendingRequest = this.bid(nextBid, accountsToUse, historyEntry);
+    } else if (historyEntry.bidChanges.length === 0) {
+      this.history.bidHistory.shift();
     }
-    this.pendingRequest = this.bid(
-      nextBid,
-      this.subaccounts.map((x) => x.index)
-    );
     this.needsRebid = false;
   }
-  async bid(bidPerSeat, subaccountRange) {
-    if (!subaccountRange.length) return;
+  async bid(bidPerSeat, subaccounts, historyEntry) {
     const prevLastBidTime = this.lastBidTime;
     try {
       this.lastBidTime = Date.now();
-      const result = await this.accountset.createMiningBids({
-        subaccountRange,
+      const submitter = await this.accountset.createMiningBidTx({
+        subaccounts,
         bidAmount: bidPerSeat,
         sendRewardsToSeed: true
       });
-      if (result.blockHash) {
+      const tip = this.options.tipPerTransaction ?? 0n;
+      const txResult = await submitter.submit({
+        tip,
+        useLatestNonce: true
+      });
+      const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
+      let blockNumber;
+      if (txResult.includedInBlock) {
         const client = await this.client;
-        const api = await client.at(result.blockHash);
-        this.stats.lastBlock = await api.query.system.number().then((x) => x.toNumber());
+        const api = await client.at(txResult.includedInBlock);
+        blockNumber = await api.query.system.number().then((x) => x.toNumber());
       }
-      this.stats.fees += result.finalFee ?? 0n;
-      this.stats.bids += subaccountRange.length;
-      if (bidPerSeat > this.stats.maxBidPerSeat) {
-        this.stats.maxBidPerSeat = bidPerSeat;
-      }
-      console.log("Done creating bids for cohort", this.cohortId);
-      if (result.bidError) throw result.bidError;
+      const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
+      this.history.onBidResult(historyEntry, {
+        blockNumber,
+        successfulBids,
+        bidPerSeat,
+        txFeePlusTip: txResult.finalFee ?? 0n,
+        bidsAttempted: subaccounts.length,
+        bidError
+      });
+      console.log("Done creating bids for cohort", {
+        successfulBids,
+        bidPerSeat,
+        blockNumber
+      });
+      if (bidError) throw bidError;
     } catch (err) {
       this.lastBidTime = prevLastBidTime;
       console.error(`Error bidding for cohort ${this.cohortId}:`, err);
@@ -2479,8 +2702,8 @@ function vaultCli() {
   ).action(async ({ tip, argons, vaultId, ratio }) => {
     const accountset = await accountsetFromCli(program2);
     const client = await accountset.client;
-    const resolvedTip = tip ? BigInt(tip * 1e6) : 0n;
-    const microgons = BigInt(argons * 1e6);
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
     const rawVault = (await client.query.vaults.vaultsById(vaultId)).unwrap();
     if (rawVault.operatorAccountId.toHuman() !== accountset.seedAddress) {
       console.error("Vault does not belong to this account");
@@ -2540,8 +2763,8 @@ function vaultCli() {
     }
     const accountset = await accountsetFromCli(program2);
     const client = await accountset.client;
-    const resolvedTip = tip ? BigInt(tip * 1e6) : 0n;
-    const microgons = BigInt(argons * 1e6);
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
     const bitcoinLocks = new BitcoinLocks(Promise.resolve(client));
     const existentialDeposit = client.consts.balances.existentialDeposit.toBigInt();
     const tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
@@ -2746,7 +2969,7 @@ function miningCli() {
           const balance = await accountset.balance();
           const feeWiggleRoom = BigInt(25e3);
           const amountAvailable = balance - feeWiggleRoom;
-          let maxBidAmount = maxBid ? BigInt(maxBid * 1e6) : void 0;
+          let maxBidAmount = maxBid ? BigInt(maxBid * MICROGONS_PER_ARGON) : void 0;
           let maxBalanceToUse = amountAvailable;
           if (maxBalance !== void 0) {
             if (maxBalance.endsWith("%")) {
@@ -2758,7 +2981,7 @@ function miningCli() {
               maxBalanceToUse = amountToBid;
             } else {
               maxBalanceToUse = BigInt(
-                Math.floor(parseFloat(maxBalance) * 1e6)
+                Math.floor(parseFloat(maxBalance) * MICROGONS_PER_ARGON)
               );
             }
             maxBidAmount ??= maxBalanceToUse / BigInt(seatsToWin);
@@ -2780,9 +3003,11 @@ function miningCli() {
             subaccountRange,
             {
               maxBid: maxBidAmount,
-              minBid: BigInt((minBid ?? 0) * 1e6),
-              bidIncrement: BigInt(Math.floor(bidIncrement * 1e6)),
-              maxBalance: maxBalanceToUse,
+              minBid: BigInt((minBid ?? 0) * MICROGONS_PER_ARGON),
+              bidIncrement: BigInt(
+                Math.floor(bidIncrement * MICROGONS_PER_ARGON)
+              ),
+              maxBudget: maxBalanceToUse,
               bidDelay
             }
           );
@@ -2814,7 +3039,10 @@ function miningCli() {
     );
     const tx = client.tx.utility.batchAll([
       client.tx.proxy.addProxy(address, "MiningBid", 0),
-      client.tx.balances.transferAllowDeath(address, BigInt(feeArgons * 1e6))
+      client.tx.balances.transferAllowDeath(
+        address,
+        BigInt(feeArgons * MICROGONS_PER_ARGON)
+      )
     ]);
     let keypair;
     try {
@@ -2863,8 +3091,8 @@ function liquidityCli() {
     parseFloat
   ).action(async ({ tip, argons, vaultId }) => {
     const accountset = await accountsetFromCli(program2);
-    const resolvedTip = tip ? BigInt(tip * 1e6) : 0n;
-    const microgons = BigInt(argons * 1e6);
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
+    const microgons = BigInt(argons * MICROGONS_PER_ARGON);
     const bidPool = new BidPool(
       accountset.client,
       accountset.txSubmitterPair
@@ -2889,7 +3117,7 @@ function liquidityCli() {
     "The tip to include with the transaction",
     parseFloat
   ).action(async ({ maxArgons, minPctSharing, tip }) => {
-    const maxAmountPerSlot = BigInt(maxArgons * 1e6);
+    const maxAmountPerSlot = BigInt(maxArgons * MICROGONS_PER_ARGON);
     const accountset = await accountsetFromCli(program2);
     const vaults = new VaultMonitor(
       accountset,
@@ -2902,7 +3130,7 @@ function liquidityCli() {
       accountset.client,
       accountset.txSubmitterPair
     );
-    const resolvedTip = tip ? BigInt(tip * 1e6) : 0n;
+    const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
     console.log("Waiting for liquidity pool space...");
     vaults.events.on(
       "liquidity-pool-space-above",
@@ -2941,7 +3169,7 @@ function bitcoinCli() {
   ).description("Watch for bitcoin space available").action(async ({ argons }) => {
     const accountset = await accountsetFromCli(program2);
     const bot = new VaultMonitor(accountset, {
-      bitcoinSpaceAvailable: argons ? BigInt(argons * 1e6) : 1n
+      bitcoinSpaceAvailable: argons ? BigInt(argons * MICROGONS_PER_ARGON) : 1n
     });
     bot.events.on("bitcoin-space-above", async (vaultId, amount) => {
       const vault = bot.vaultsById[vaultId];
@@ -2970,13 +3198,13 @@ function bitcoinCli() {
     parseFloat,
     0
   ).action(async ({ argons, bitcoinXpub, maxLockFee, tip }) => {
-    const amountToLock = BigInt(argons * 1e6);
+    const amountToLock = BigInt(argons * MICROGONS_PER_ARGON);
     const accountset = await accountsetFromCli(program2);
     await BitcoinLocks.waitForSpace(accountset, {
       argonAmount: amountToLock,
       bitcoinXpub,
-      maxLockFee: maxLockFee !== void 0 ? BigInt(maxLockFee * 1e6) : void 0,
-      tip: BigInt(tip * 1e6)
+      maxLockFee: maxLockFee !== void 0 ? BigInt(maxLockFee * MICROGONS_PER_ARGON) : void 0,
+      tip: BigInt(tip * MICROGONS_PER_ARGON)
     }).then(({ vaultId, satoshis, txFee, btcFee }) => {
       console.log(
         `Locked ${satoshis} satoshis in vault ${vaultId}. Tx fee=${formatArgons(
@@ -3001,8 +3229,13 @@ async function keyringFromFile(opts) {
   }
   const path = opts.filePath.replace("~", os.homedir());
   const json = JSON.parse(await readFile(path, "utf-8"));
+  let passphrase = opts.passphrase;
+  if (opts.passphraseFile) {
+    const passphrasePath = opts.passphraseFile.replace("~", os.homedir());
+    passphrase = await readFile(passphrasePath, "utf-8");
+  }
   const mainAccount = new Keyring().createFromJson(json);
-  mainAccount.decodePkcs8(opts.passphrase);
+  mainAccount.decodePkcs8(passphrase);
   return mainAccount;
 }
 async function saveKeyringPair(opts) {
@@ -3037,6 +3270,11 @@ function buildCli() {
       "--account-passphrase <password>",
       "The password for your seed file"
     ).env("ACCOUNT_PASSPHRASE")
+  ).addOption(
+    new Option2(
+      "--account-passphrase-file <path>",
+      "The path to a password for your seed file"
+    )
   ).addOption(
     new Option2(
       "-s, --subaccounts <range>",
@@ -3053,7 +3291,8 @@ async function accountsetFromCli(program2, proxyForAddress) {
   if (opts.accountFilePath) {
     keypair = await keyringFromFile({
       filePath: opts.accountFilePath,
-      passphrase: opts.accountPassphrase
+      passphrase: opts.accountPassphrase,
+      passphraseFile: opts.accountPassphraseFile
     });
   }
   if (!keypair) {