@argonprotocol/mainchain 1.3.2 → 1.3.3

package/lib/{chunk-SHAEHPI5.cjs → chunk-OFYVHBKG.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;// src/interfaces/augment-api-consts.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11;// src/interfaces/augment-api-consts.ts
 require('@polkadot/api-base/types/consts');
 
 // src/interfaces/augment-api-errors.ts
@@ -56,7 +56,7 @@ var WageProtector = class _WageProtector {
         new _WageProtector({
           argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
           argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
-          finalizedBlock: Buffer.from(finalizedBlock),
+          finalizedBlock: new Uint8Array(finalizedBlock),
           tick: cpi.value.tick.toBigInt()
         })
       );
@@ -81,9 +81,29 @@ 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: _nullishCoalesce(config.debug, () => ( getEnvVar("DEBUG") === "true")),
+    keysVersion: _nullishCoalesce(config.keysVersion, () => ( (getEnvVar("KEYS_VERSION") ? parseInt(getEnvVar("KEYS_VERSION")) : void 0))),
+    keysMnemonic: _nullishCoalesce(config.keysMnemonic, () => ( getEnvVar("KEYS_MNEMONIC"))),
+    subaccountRange: _nullishCoalesce(_nullishCoalesce(config.subaccountRange, () => ( getEnvVar("SUBACCOUNT_RANGE"))), () => ( "0-9"))
+  };
+}
+
 // src/TxSubmitter.ts
 function logExtrinsicResult(result) {
-  if (process.env.DEBUG) {
+  if (getConfig().debug) {
     const json = result.status.toJSON();
     const status = Object.keys(json)[0];
     console.debug('Transaction update: "%s"', status, json[status]);
@@ -113,8 +133,10 @@ var TxSubmitter = class {
     return { canAfford, availableBalance, txFee: fees };
   }
   async submit(options = {}) {
-    const { logResults } = options;
+    const { logResults, waitForBlock, useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
     const result = new TxResult(this.client, logResults);
+    result.onResultCallback = options.onResultCallback;
     let toHuman = this.tx.toHuman().method;
     let txString = [];
     let api = formatCall(toHuman);
@@ -132,12 +154,12 @@ var TxSubmitter = class {
       args.push(toHuman.args);
     }
     args.unshift(txString.join("->"));
-    if (options.useLatestNonce && !options.nonce) {
-      options.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
+    if (useLatestNonce && !apiOptions.nonce) {
+      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
     }
-    console.log("Submitting transaction:", ...args);
-    await this.tx.signAndSend(this.pair, options, result.onResult.bind(result));
-    if (options.waitForBlock) {
+    console.log("Submitting transaction from %s:", this.pair.address, ...args);
+    await this.tx.signAndSend(this.pair, apiOptions, result.onResult.bind(result));
+    if (waitForBlock) {
       await result.inBlockPromise;
     }
     return result;
@@ -184,6 +206,7 @@ var TxResult = (_class = class {
   
   
   
+  
   onResult(result) {
     this.status = result.status;
     if (this.shouldLog) {
@@ -191,7 +214,7 @@ var TxResult = (_class = class {
     }
     const { events, status, dispatchError, isFinalized } = result;
     if (status.isInBlock) {
-      this.includedInBlock = Buffer.from(status.asInBlock);
+      this.includedInBlock = new Uint8Array(status.asInBlock);
       let encounteredError = dispatchError;
       let batchErrorIndex;
       for (const event of events) {
@@ -211,12 +234,13 @@ var TxResult = (_class = class {
         const error = dispatchErrorToExtrinsicError(this.client, encounteredError, batchErrorIndex);
         this.reject(error);
       } else {
-        this.inBlockResolve(Buffer.from(status.asInBlock));
+        this.inBlockResolve(new Uint8Array(status.asInBlock));
       }
     }
     if (isFinalized) {
       this.finalizedResolve(status.asFinalized);
     }
+    _optionalChain([this, 'access', _2 => _2.onResultCallback, 'optionalCall', _3 => _3(result)]);
   }
   reject(error) {
     this.inBlockReject(error);
@@ -226,6 +250,7 @@ var TxResult = (_class = class {
 
 // src/utils.ts
 var _bignumberjs = require('bignumber.js'); var BN = _interopRequireWildcard(_bignumberjs); var BN2 = _interopRequireWildcard(_bignumberjs);
+var _util = require('@polkadot/util');
 var { ROUND_FLOOR } = BN;
 var MICROGONS_PER_ARGON = 1e6;
 function formatArgons(x) {
@@ -271,10 +296,11 @@ async function gettersToObject(obj) {
   }
   return result;
 }
-function toFixedNumber(value, base) {
-  const decimalFactor = new (0, BN.default)(10).pow(base);
-  const rawValue = new (0, BN.default)(value.toString());
-  return BigInt(rawValue.times(decimalFactor).toFixed(0, ROUND_FLOOR));
+function toFixedNumber(value, decimals) {
+  const factor = new (0, BN.default)(10).pow(decimals);
+  const bn = new (0, BN.default)(value);
+  const int = bn.times(factor).integerValue(BN.default.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
 }
 function convertNumberToFixedU128(value) {
   return toFixedNumber(value, 18);
@@ -295,7 +321,7 @@ function convertNumberToPermill(value) {
 function eventDataToJson(event) {
   const obj = {};
   event.data.forEach((data, index) => {
-    const name = _optionalChain([event, 'access', _2 => _2.data, 'access', _3 => _3.names, 'optionalAccess', _4 => _4[index]]);
+    const name = _optionalChain([event, 'access', _4 => _4.data, 'access', _5 => _5.names, 'optionalAccess', _6 => _6[index]]);
     obj[_nullishCoalesce(name, () => ( `${index}`))] = data.toJSON();
   });
   return obj;
@@ -356,8 +382,12 @@ var JsonExt = class {
         if (typeof v === "bigint") {
           return `${v}n`;
         }
-        if (Buffer.isBuffer(v)) {
-          return Buffer.from(v).toJSON();
+        if (v instanceof Uint8Array) {
+          return {
+            type: "Buffer",
+            data: Array.from(v)
+            // Convert Uint8Array to an array of numbers
+          };
         }
         return v;
       },
@@ -370,7 +400,7 @@ var JsonExt = class {
         return BigInt(v.slice(0, -1));
       }
       if (typeof v === "object" && v !== null && v.type === "Buffer" && Array.isArray(v.data)) {
-        return Buffer.from(v.data);
+        return _util.hexToU8a.call(void 0, v.data);
       }
       return v;
     });
@@ -389,7 +419,7 @@ var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init2.c
   on(event, cb) {
     (this.events[event] ||= []).push(cb);
     return () => {
-      this.events[event] = _optionalChain([this, 'access', _5 => _5.events, 'access', _6 => _6[event], 'optionalAccess', _7 => _7.filter, 'call', _8 => _8((i) => cb !== i)]);
+      this.events[event] = _optionalChain([this, 'access', _7 => _7.events, 'access', _8 => _8[event], 'optionalAccess', _9 => _9.filter, 'call', _10 => _10((i) => cb !== i)]);
     };
   }
 }, _class2);
@@ -412,9 +442,6 @@ var AccountRegistry = (_class3 = class _AccountRegistry {
   static __initStatic() {this.factory = (name) => new _AccountRegistry(name)}
 }, _class3.__initStatic(), _class3);
 
-// src/Accountset.ts
-var _process = require('process'); var process2 = _interopRequireWildcard(_process);
-
 // src/BlockWatch.ts
 function getTickFromHeader(client, header) {
   for (const x of header.digest.logs) {
@@ -562,7 +589,7 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
             if (this.options.shouldLog) {
               console.log(
                 `> [Failed Tx] ${section}.${name} -> ${ext.method.section}.${ext.method.method} (nonce=${ext.nonce})`,
-                _optionalChain([ext, 'access', _9 => _9.toHuman, 'call', _10 => _10(), 'optionalAccess', _11 => _11.method, 'optionalAccess', _12 => _12.args])
+                _optionalChain([ext, 'access', _11 => _11.toHuman, 'call', _12 => _12(), 'optionalAccess', _13 => _13.method, 'optionalAccess', _14 => _14.args])
               );
             }
           } else {
@@ -628,13 +655,13 @@ var FrameCalculator = class {
       slotBiddingStartAfterTicks: x.slotBiddingStartAfterTicks.toNumber()
     }));
     this.genesisTick ??= await client.query.ticks.genesisTick().then((x) => x.toNumber());
-    const config = this.miningConfig;
+    const config2 = this.miningConfig;
     const genesisTick = this.genesisTick;
     return {
-      ticksBetweenFrames: config.ticksBetweenSlots,
-      slotBiddingStartAfterTicks: config.slotBiddingStartAfterTicks,
+      ticksBetweenFrames: config2.ticksBetweenSlots,
+      slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
       genesisTick,
-      biddingStartTick: genesisTick + config.slotBiddingStartAfterTicks
+      biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
     };
   }
 };
@@ -645,10 +672,10 @@ var AccountMiners = (_class5 = class _AccountMiners {
     this.accountset = accountset;
     this.options = options;
     this.frameCalculator = new FrameCalculator();
-    for (const seat of registeredMiners) {
-      this.trackedAccountsByAddress[seat.address] = {
-        startingFrameId: seat.startingFrameId,
-        subaccountIndex: seat.subaccountIndex
+    for (const miner of registeredMiners) {
+      this.trackedAccountsByAddress[miner.address] = {
+        startingFrameId: miner.seat.startingFrameId,
+        subaccountIndex: miner.subaccountIndex
       };
     }
   }
@@ -760,6 +787,7 @@ var AccountMiners = (_class5 = class _AccountMiners {
 }, _class5);
 
 // src/Accountset.ts
+
 var Accountset = (_class6 = class {
   
   __init9() {this.isProxy = false}
@@ -817,7 +845,7 @@ var Accountset = (_class6 = class {
       return {
         address,
         amount: account.data.free.toBigInt(),
-        index: _nullishCoalesce(_optionalChain([this, 'access', _13 => _13.subAccountsByAddress, 'access', _14 => _14[address], 'optionalAccess', _15 => _15.index]), () => ( Number.NaN))
+        index: _nullishCoalesce(_optionalChain([this, 'access', _15 => _15.subAccountsByAddress, 'access', _16 => _16[address], 'optionalAccess', _17 => _17.index]), () => ( Number.NaN))
       };
     });
   }
@@ -831,7 +859,7 @@ var Accountset = (_class6 = class {
       return {
         address,
         amount: account.free.toBigInt(),
-        index: _nullishCoalesce(_optionalChain([this, 'access', _16 => _16.subAccountsByAddress, 'access', _17 => _17[address], 'optionalAccess', _18 => _18.index]), () => ( Number.NaN))
+        index: _nullishCoalesce(_optionalChain([this, 'access', _18 => _18.subAccountsByAddress, 'access', _19 => _19[address], 'optionalAccess', _20 => _20.index]), () => ( Number.NaN))
       };
     });
   }
@@ -880,9 +908,9 @@ var Accountset = (_class6 = class {
       const [frameIdRaw, indexRaw] = rawIndices[i].value;
       const frameId = frameIdRaw.toNumber();
       const index = indexRaw.toNumber();
-      const bidAmount = _optionalChain([bidAmountsByFrame, 'access', _19 => _19[frameId], 'optionalAccess', _20 => _20[index]]);
+      const bidAmount = _optionalChain([bidAmountsByFrame, 'access', _21 => _21[frameId], 'optionalAccess', _22 => _22[index]]);
       addressToMiningIndex[address] = {
-        frameId,
+        startingFrameId: frameId,
         index,
         bidAmount: _nullishCoalesce(bidAmount, () => ( 0n))
       };
@@ -892,13 +920,13 @@ var Accountset = (_class6 = class {
       const cohort = addressToMiningIndex[address];
       let isLastDay = false;
       if (cohort !== void 0) {
-        isLastDay = nextFrameId.toNumber() - cohort.frameId === 10;
+        isLastDay = nextFrameId.toNumber() - cohort.startingFrameId === 10;
       }
       return {
         address,
         seat: cohort,
         isLastDay,
-        subaccountIndex: _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.subAccountsByAddress, 'access', _22 => _22[address], 'optionalAccess', _23 => _23.index]), () => ( Number.NaN))
+        subaccountIndex: _nullishCoalesce(_optionalChain([this, 'access', _23 => _23.subAccountsByAddress, 'access', _24 => _24[address], 'optionalAccess', _25 => _25.index]), () => ( Number.NaN))
       };
     });
   }
@@ -912,7 +940,7 @@ var Accountset = (_class6 = class {
       return {
         ...miner,
         hasWinningBid: !!bid,
-        bidAmount: _nullishCoalesce(_nullishCoalesce(_optionalChain([bid, 'optionalAccess', _24 => _24.bid, 'access', _25 => _25.toBigInt, 'call', _26 => _26()]), () => ( _optionalChain([miner, 'access', _27 => _27.seat, 'optionalAccess', _28 => _28.bidAmount]))), () => ( 0n))
+        bidAmount: _nullishCoalesce(_nullishCoalesce(_optionalChain([bid, 'optionalAccess', _26 => _26.bid, 'access', _27 => _27.toBigInt, 'call', _28 => _28()]), () => ( _optionalChain([miner, 'access', _29 => _29.seat, 'optionalAccess', _30 => _30.bidAmount]))), () => ( 0n))
       };
     });
   }
@@ -928,9 +956,9 @@ var Accountset = (_class6 = class {
       const entry = registrationsByAddress[address];
       return {
         address,
-        bidPlace: _optionalChain([entry, 'optionalAccess', _29 => _29.index]),
-        bidAmount: _optionalChain([entry, 'optionalAccess', _30 => _30.bid, 'optionalAccess', _31 => _31.toBigInt, 'call', _32 => _32()]),
-        index: _nullishCoalesce(_optionalChain([this, 'access', _33 => _33.subAccountsByAddress, 'access', _34 => _34[address], 'optionalAccess', _35 => _35.index]), () => ( Number.NaN))
+        bidPlace: _optionalChain([entry, 'optionalAccess', _31 => _31.index]),
+        bidAmount: _optionalChain([entry, 'optionalAccess', _32 => _32.bid, 'optionalAccess', _33 => _33.toBigInt, 'call', _34 => _34()]),
+        index: _nullishCoalesce(_optionalChain([this, 'access', _35 => _35.subAccountsByAddress, 'access', _36 => _36[address], 'optionalAccess', _37 => _37.index]), () => ( Number.NaN))
       };
     });
   }
@@ -980,23 +1008,23 @@ var Accountset = (_class6 = class {
       {
         index: "main",
         address: this.seedAddress,
-        argons: formatArgons(_nullishCoalesce(_optionalChain([argons, 'access', _36 => _36.find, 'call', _37 => _37((x) => x.address === this.seedAddress), 'optionalAccess', _38 => _38.amount]), () => ( 0n))),
-        argonots: formatArgons(_nullishCoalesce(_optionalChain([argonots, 'access', _39 => _39.find, 'call', _40 => _40((x) => x.address === this.seedAddress), 'optionalAccess', _41 => _41.amount]), () => ( 0n)))
+        argons: formatArgons(_nullishCoalesce(_optionalChain([argons, 'access', _38 => _38.find, 'call', _39 => _39((x) => x.address === this.seedAddress), 'optionalAccess', _40 => _40.amount]), () => ( 0n))),
+        argonots: formatArgons(_nullishCoalesce(_optionalChain([argonots, 'access', _41 => _41.find, 'call', _42 => _42((x) => x.address === this.seedAddress), 'optionalAccess', _43 => _43.amount]), () => ( 0n)))
       }
     ];
     for (const [address, { index }] of Object.entries(this.subAccountsByAddress)) {
-      const argonAmount = _nullishCoalesce(_optionalChain([argons, 'access', _42 => _42.find, 'call', _43 => _43((x) => x.address === address), 'optionalAccess', _44 => _44.amount]), () => ( 0n));
-      const argonotAmount = _nullishCoalesce(_optionalChain([argonots, 'access', _45 => _45.find, 'call', _46 => _46((x) => x.address === address), 'optionalAccess', _47 => _47.amount]), () => ( 0n));
+      const argonAmount = _nullishCoalesce(_optionalChain([argons, 'access', _44 => _44.find, 'call', _45 => _45((x) => x.address === address), 'optionalAccess', _46 => _46.amount]), () => ( 0n));
+      const argonotAmount = _nullishCoalesce(_optionalChain([argonots, 'access', _47 => _47.find, 'call', _48 => _48((x) => x.address === address), 'optionalAccess', _49 => _49.amount]), () => ( 0n));
       const bid = bids.find((x) => x.address === address);
-      const seat = _optionalChain([seats, 'access', _48 => _48.find, 'call', _49 => _49((x) => x.address === address), 'optionalAccess', _50 => _50.seat]);
+      const seat = _optionalChain([seats, 'access', _50 => _50.find, 'call', _51 => _51((x) => x.address === address), 'optionalAccess', _52 => _52.seat]);
       const entry = {
         index: ` //${index}`,
         address,
         argons: formatArgons(argonAmount),
         argonots: formatArgons(argonotAmount),
         seat,
-        bidPlace: _optionalChain([bid, 'optionalAccess', _51 => _51.bidPlace]),
-        bidAmount: _nullishCoalesce(_optionalChain([bid, 'optionalAccess', _52 => _52.bidAmount]), () => ( 0n))
+        bidPlace: _optionalChain([bid, 'optionalAccess', _53 => _53.bidPlace]),
+        bidAmount: _nullishCoalesce(_optionalChain([bid, 'optionalAccess', _54 => _54.bidAmount]), () => ( 0n))
       };
       if (accountSubset) {
         entry.isWorkingOn = accountSubset.some((x) => x.address === address);
@@ -1021,11 +1049,9 @@ var Accountset = (_class6 = class {
     await client.disconnect();
   }
   keys(keysVersion) {
-    let version = _nullishCoalesce(keysVersion, () => ( 0));
-    if (process2.env.KEYS_VERSION) {
-      version = _nullishCoalesce(parseInt(process2.env.KEYS_VERSION), () => ( 0));
-    }
-    const seedMnemonic = _nullishCoalesce(this.sessionKeyMnemonic, () => ( process2.env.KEYS_MNEMONIC));
+    const config2 = getConfig();
+    let version = _nullishCoalesce(_nullishCoalesce(keysVersion, () => ( config2.keysVersion)), () => ( 0));
+    const seedMnemonic = _nullishCoalesce(this.sessionKeyMnemonic, () => ( config2.keysMnemonic));
     if (!seedMnemonic) {
       throw new Error("KEYS_MNEMONIC environment variable not set. Cannot derive keys.");
     }
@@ -1040,12 +1066,12 @@ var Accountset = (_class6 = class {
     return {
       seal: {
         privateKey: blockSealKey,
-        publicKey: `0x${Buffer.from(blockSealAccount.publicKey).toString("hex")}`,
+        publicKey: _util.u8aToHex.call(void 0, blockSealAccount.publicKey),
         rawPublicKey: blockSealAccount.publicKey
       },
       gran: {
         privateKey: granKey,
-        publicKey: `0x${Buffer.from(grandpaAccount.publicKey).toString("hex")}`,
+        publicKey: _util.u8aToHex.call(void 0, grandpaAccount.publicKey),
         rawPublicKey: grandpaAccount.publicKey
       }
     };
@@ -1148,10 +1174,11 @@ var Accountset = (_class6 = class {
 }, _class6);
 function getDefaultSubaccountRange() {
   try {
-    return parseSubaccountRange(_nullishCoalesce(process2.env.SUBACCOUNT_RANGE, () => ( "0-9")));
+    const config2 = getConfig();
+    return parseSubaccountRange(_nullishCoalesce(config2.subaccountRange, () => ( "0-9")));
   } catch (e2) {
     console.error(
-      "Failed to parse SUBACCOUNT_RANGE environment variable. Defaulting to 0-9. Please check the format of the SUBACCOUNT_RANGE variable."
+      "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);
   }
@@ -1190,7 +1217,7 @@ var MiningBids = (_class7 = class {
   __init11() {this.nextCohort = []}
   async maxCohortSize() {
     const client = await this.client;
-    return client.consts.miningSlot.maxCohortSize.toNumber();
+    return client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
   }
   async onCohortChange(options) {
     const { onBiddingStart, onBiddingEnd } = options;
@@ -1205,12 +1232,12 @@ var MiningBids = (_class7 = class {
         const nextFrameId = rawNextCohortStartingFrameId.toNumber();
         if (isBiddingOpen.isTrue) {
           if (openCohortStartingFrameId !== 0) {
-            await _optionalChain([onBiddingEnd, 'optionalCall', _53 => _53(openCohortStartingFrameId)]);
+            await _optionalChain([onBiddingEnd, 'optionalCall', _55 => _55(openCohortStartingFrameId)]);
           }
           openCohortStartingFrameId = nextFrameId;
-          await _optionalChain([onBiddingStart, 'optionalCall', _54 => _54(nextFrameId)]);
+          await _optionalChain([onBiddingStart, 'optionalCall', _56 => _56(nextFrameId)]);
         } else {
-          await _optionalChain([onBiddingEnd, 'optionalCall', _55 => _55(nextFrameId)]);
+          await _optionalChain([onBiddingEnd, 'optionalCall', _57 => _57(nextFrameId)]);
           openCohortStartingFrameId = 0;
         }
       }
@@ -1265,10 +1292,30 @@ var MiningBids = (_class7 = class {
 // src/Vault.ts
 
 var _bs58check = require('bs58check'); var _bs58check2 = _interopRequireDefault(_bs58check);
+
 var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
 var Vault = (_class8 = class _Vault {
   constructor(id, vault, tickDuration) {;_class8.prototype.__init12.call(this);
     this.tickDuration = tickDuration;
+    this.vaultId = id;
+    this.load(vault);
+    this.openedTick = vault.openedTick.toNumber();
+    this.openedDate = new Date(this.openedTick * this.tickDuration);
+  }
+  
+  
+  
+  
+  __init12() {this.argonsScheduledForRelease = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  
+  
+  
+  
+  load(vault) {
     this.securitization = vault.securitization.toBigInt();
     this.securitizationRatio = convertFixedU128ToBigNumber(vault.securitizationRatio.toBigInt());
     this.argonsLocked = vault.argonsLocked.toBigInt();
@@ -1290,7 +1337,6 @@ var Vault = (_class8 = class _Vault {
     };
     this.operatorAccountId = vault.operatorAccountId.toString();
     this.isClosed = vault.isClosed.valueOf();
-    this.vaultId = id;
     if (vault.pendingTerms.isSome) {
       const [tickApply, terms] = vault.pendingTerms.value;
       this.pendingTermsChangeTick = tickApply.toNumber();
@@ -1304,22 +1350,7 @@ var Vault = (_class8 = class _Vault {
         )
       };
     }
-    this.openedTick = vault.openedTick.toNumber();
-    this.openedDate = new Date(this.openedTick * tickDuration);
   }
-  
-  
-  
-  
-  __init12() {this.argonsScheduledForRelease = /* @__PURE__ */ new Map()}
-  
-  
-  
-  
-  
-  
-  
-  
   availableBitcoinSpace() {
     const recoverySecuritization = this.recoverySecuritization();
     const reLockable = this.getRelockCapacity();
@@ -1356,48 +1387,83 @@ var Vault = (_class8 = class _Vault {
     const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BN.default.ROUND_CEIL);
     return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
   }
-  static async get(client, vaultId) {
+  static async get(client, vaultId, tickDurationMillis) {
     const rawVault = await client.query.vaults.vaultsById(vaultId);
     if (rawVault.isNone) {
       throw new Error(`Vault with id ${vaultId} not found`);
     }
-    const tickDuration = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    const tickDuration = await _asyncNullishCoalesce(tickDurationMillis, async () => ( await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber())));
     return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
   }
-  static async create(client, keypair, args, config = {}) {
-    const { securitization, securitizationRatio, annualPercentRate, baseFee, bitcoinXpub, tip } = args;
-    let xpubBytes = Buffer.from(bitcoinXpub, "hex");
+  static async create(client, keypair, args, config2 = {}) {
+    const {
+      securitization,
+      securitizationRatio,
+      annualPercentRate,
+      baseFee,
+      bitcoinXpub,
+      tip,
+      doNotExceedBalance,
+      progressCallback
+    } = args;
+    let xpubBytes = _util.hexToU8a.call(void 0, bitcoinXpub);
     if (xpubBytes.length !== 78) {
       if (bitcoinXpub.startsWith("xpub") || bitcoinXpub.startsWith("tpub") || bitcoinXpub.startsWith("zpub")) {
         const bytes = _bs58check2.default.decode(bitcoinXpub);
         if (bytes.length !== 78) {
           throw new Error("Invalid Bitcoin xpub key length, must be 78 bytes");
         }
-        xpubBytes = Buffer.from(bytes);
+        xpubBytes = bytes;
+      }
+    }
+    let vaultParams = {
+      terms: {
+        // convert to fixed u128
+        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
+        bitcoinBaseFee: BigInt(baseFee),
+        liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
+      },
+      securitizationRatio: toFixedNumber(securitizationRatio, 18),
+      securitization: BigInt(securitization),
+      bitcoinXpubkey: xpubBytes
+    };
+    let tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
+    if (doNotExceedBalance) {
+      const finalTip = _nullishCoalesce(tip, () => ( 0n));
+      let txFee = await tx.feeEstimate(finalTip);
+      while (txFee + finalTip + vaultParams.securitization > doNotExceedBalance) {
+        vaultParams.securitization = doNotExceedBalance - txFee - finalTip;
+        tx.tx = client.tx.vaults.create(vaultParams);
+        txFee = await tx.feeEstimate(finalTip);
       }
     }
-    const tx = new TxSubmitter(
-      client,
-      client.tx.vaults.create({
-        terms: {
-          // convert to fixed u128
-          bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
-          bitcoinBaseFee: BigInt(baseFee),
-          liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
-        },
-        securitizationRatio: toFixedNumber(securitizationRatio, 18),
-        securitization: BigInt(securitization),
-        bitcoinXpubkey: xpubBytes
-      }),
-      keypair
-    );
     const canAfford = await tx.canAfford({ tip, unavailableBalance: BigInt(securitization) });
     if (!canAfford.canAfford) {
       throw new Error(
         `Insufficient balance to create vault. Required: ${formatArgons(securitization)}, Available: ${formatArgons(canAfford.availableBalance)}`
       );
     }
-    const result = await tx.submit({ waitForBlock: true, tip });
+    const result = await tx.submit({
+      tip,
+      useLatestNonce: true,
+      waitForBlock: true,
+      onResultCallback(result2) {
+        let percent = 0;
+        if (result2.status.isInvalid || result2.status.isDropped || result2.status.isUsurped || result2.status.isRetracted) {
+          percent = 1;
+        } else if (result2.status.isReady) {
+          percent = 0;
+        } else if (result2.status.isBroadcast) {
+          percent = 0.5;
+        } else if (result2.status.isInBlock) {
+          percent = 1;
+        } else if (result2.status.isFinalized) {
+          percent = 1.1;
+        }
+        _optionalChain([progressCallback, 'optionalCall', _58 => _58(percent, result2.status)]);
+      }
+    });
+    await result.inBlockPromise;
     let vaultId;
     for (const event of result.events) {
       if (client.events.vaults.VaultCreated.is(event)) {
@@ -1412,8 +1478,9 @@ var Vault = (_class8 = class _Vault {
     if (rawVault.isNone) {
       throw new Error("Vault creation failed, vault not found");
     }
-    const tickDuration = await _asyncNullishCoalesce(config.tickDurationMillis, async () => ( await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber())));
-    return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+    const tickDuration = await _asyncNullishCoalesce(config2.tickDurationMillis, async () => ( await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber())));
+    const vault = new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+    return { vault, txResult: result };
   }
 }, _class8);
 
@@ -1465,7 +1532,7 @@ var VaultMonitor = (_class9 = class {
     const client = await this.mainchain;
     this.tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
     const blockHeader = await client.rpc.chain.getHeader();
-    const blockHash = Buffer.from(blockHeader.hash);
+    const blockHash = new Uint8Array(blockHeader.hash);
     console.log(
       `${justPrint ? "Run" : "Started"} at block ${blockHeader.number} - ${blockHeader.hash.toHuman()}`
     );
@@ -1590,151 +1657,13 @@ var VaultMonitor = (_class9 = class {
   }
 }, _class9);
 
-// src/CohortBidderHistory.ts
-var CohortBidderHistory = (_class10 = class _CohortBidderHistory {
-  constructor(cohortStartingFrameId, subaccounts) {;_class10.prototype.__init19.call(this);_class10.prototype.__init20.call(this);_class10.prototype.__init21.call(this);_class10.prototype.__init22.call(this);_class10.prototype.__init23.call(this);
-    this.cohortStartingFrameId = cohortStartingFrameId;
-    this.subaccounts = subaccounts;
-    this.maxSeatsInPlay = this.subaccounts.length;
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  __init19() {this.bidHistory = []}
-  __init20() {this.stats = {
-    // number of seats won
-    seatsWon: 0,
-    // sum of argons bid in successful bids
-    totalArgonsBid: 0n,
-    // total number of bids placed (includes 1 per seat)
-    bidsAttempted: 0,
-    // fees including the tip
-    fees: 0n,
-    // Max bid per seat
-    maxBidPerSeat: 0n,
-    // The cost in argonots of each seat
-    argonotsPerSeat: 0n,
-    // The argonot price in USD for cost basis
-    argonotUsdPrice: 0,
-    // The cohort expected argons per block
-    cohortArgonsPerBlock: 0n,
-    // The last block that bids are synced to
-    lastBlockNumber: 0
-  }}
-  __init21() {this.lastBids = []}
-  __init22() {this.myAddresses = /* @__PURE__ */ new Set()}
-  __init23() {this.maxSeatsInPlay = 0}
-  async init(client) {
-    if (!this.stats.argonotsPerSeat) {
-      const startingStats = await _CohortBidderHistory.getStartingData(client);
-      Object.assign(this.stats, startingStats);
-    }
-  }
-  maybeReducingSeats(maxSeats, reason, historyEntry) {
-    if (this.maxSeatsInPlay > maxSeats) {
-      historyEntry.maxSeatsReductionReason = reason;
-    }
-    this.maxSeatsInPlay = maxSeats;
-    historyEntry.maxSeatsInPlay = maxSeats;
-  }
-  trackChange(next, blockNumber, tick, isLastEntry = false) {
-    let winningBids = 0;
-    let totalArgonsBid = 0n;
-    const nextEntrants = [];
-    for (const x of next) {
-      const bid = x.bid.toBigInt();
-      const address = x.accountId.toHuman();
-      nextEntrants.push({ address, bid });
-      if (this.myAddresses.has(address)) {
-        winningBids++;
-        totalArgonsBid += bid;
-      }
-    }
-    this.stats.seatsWon = winningBids;
-    this.stats.totalArgonsBid = totalArgonsBid;
-    this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
-    const historyEntry = {
-      cohortStartingFrameId: this.cohortStartingFrameId,
-      blockNumber,
-      tick,
-      bidChanges: [],
-      winningSeats: winningBids,
-      maxSeatsInPlay: this.maxSeatsInPlay
-    };
-    const hasDiffs = JsonExt.stringify(nextEntrants) !== JsonExt.stringify(this.lastBids);
-    if (!isLastEntry || hasDiffs) {
-      this.bidHistory.unshift(historyEntry);
-    }
-    if (hasDiffs) {
-      nextEntrants.forEach(({ address, bid }, i) => {
-        const prevBidIndex = this.lastBids.findIndex((y) => y.address === address);
-        const entry = {
-          address,
-          bidAmount: bid,
-          bidPosition: i,
-          prevPosition: prevBidIndex === -1 ? null : prevBidIndex
-        };
-        if (prevBidIndex !== -1) {
-          const prevBidAmount = this.lastBids[prevBidIndex].bid;
-          if (prevBidAmount !== bid) {
-            entry.prevBidAmount = prevBidAmount;
-          }
-        }
-        historyEntry.bidChanges.push(entry);
-      });
-      this.lastBids.forEach(({ address, bid }, i) => {
-        const nextBid = nextEntrants.some((y) => y.address === address);
-        if (!nextBid) {
-          historyEntry.bidChanges.push({
-            address,
-            bidAmount: bid,
-            bidPosition: null,
-            prevPosition: i
-          });
-        }
-      });
-      this.lastBids = nextEntrants;
-    }
-    return historyEntry;
-  }
-  onBidResult(historyEntry, param) {
-    const { txFeePlusTip, bidPerSeat, bidsAttempted, successfulBids, blockNumber, bidError } = param;
-    this.stats.fees += txFeePlusTip;
-    this.stats.bidsAttempted += bidsAttempted;
-    if (bidPerSeat > this.stats.maxBidPerSeat) {
-      this.stats.maxBidPerSeat = bidPerSeat;
-    }
-    if (blockNumber !== void 0) {
-      this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
-    }
-    if (historyEntry.myBidsPlaced) {
-      historyEntry.myBidsPlaced.failureReason = bidError;
-      historyEntry.myBidsPlaced.successfulBids = successfulBids;
-      historyEntry.myBidsPlaced.txFeePlusTip = txFeePlusTip;
-    }
-  }
-  static async getStartingData(api) {
-    const argonotPrice = await api.query.priceIndex.current();
-    let argonotUsdPrice = 0;
-    if (argonotPrice.isSome) {
-      argonotUsdPrice = convertFixedU128ToBigNumber(
-        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
-      ).toNumber();
-    }
-    const argonotsPerSeat = await api.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
-    const cohortArgonsPerBlock = await api.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
-    return { argonotsPerSeat, argonotUsdPrice, cohortArgonsPerBlock };
-  }
-}, _class10);
-
 // src/CohortBidder.ts
-var CohortBidder = (_class11 = class {
-  constructor(accountset, cohortStartingFrameId, subaccounts, options) {;_class11.prototype.__init24.call(this);_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);_class11.prototype.__init27.call(this);
+var CohortBidder = (_class10 = class {
+  constructor(accountset, cohortStartingFrameId, subaccounts, options) {;_class10.prototype.__init19.call(this);_class10.prototype.__init20.call(this);_class10.prototype.__init21.call(this);_class10.prototype.__init22.call(this);_class10.prototype.__init23.call(this);_class10.prototype.__init24.call(this);_class10.prototype.__init25.call(this);_class10.prototype.__init26.call(this);
     this.accountset = accountset;
     this.cohortStartingFrameId = cohortStartingFrameId;
     this.subaccounts = subaccounts;
     this.options = options;
-    this.history = new CohortBidderHistory(cohortStartingFrameId, subaccounts);
     this.subaccounts.forEach((x) => {
       this.myAddresses.add(x.address);
     });
@@ -1742,23 +1671,52 @@ var CohortBidder = (_class11 = class {
   get client() {
     return this.accountset.client;
   }
-  get stats() {
-    return this.history.stats;
-  }
-  get bidHistory() {
-    return this.history.bidHistory;
-  }
+  __init19() {this.txFees = 0n}
+  __init20() {this.winningBids = []}
   
   
   
-  __init24() {this.isStopped = false}
-  __init25() {this.needsRebid = false}
-  __init26() {this.lastBidTime = 0}
+  __init21() {this.isStopped = false}
+  __init22() {this.needsRebid = false}
+  __init23() {this.lastBidTime = 0}
   
+  __init24() {this.minIncrement = 10000n}
   
-  __init27() {this.myAddresses = /* @__PURE__ */ new Set()}
+  __init25() {this.lastBidBlockNumber = 0}
+  __init26() {this.myAddresses = /* @__PURE__ */ new Set()}
+  async start() {
+    console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
+      maxBid: formatArgons(this.options.maxBid),
+      minBid: formatArgons(this.options.minBid),
+      bidIncrement: formatArgons(this.options.bidIncrement),
+      maxBudget: formatArgons(this.options.maxBudget),
+      bidDelay: this.options.bidDelay,
+      subaccounts: this.subaccounts
+    });
+    const client = await this.client;
+    this.minIncrement = client.consts.miningSlot.bidIncrements.toBigInt();
+    this.nextCohortSize = await client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
+    if (this.subaccounts.length > this.nextCohortSize) {
+      console.info(
+        `Cohort size ${this.nextCohortSize} is less than provided subaccounts ${this.subaccounts.length}.`
+      );
+      this.subaccounts.length = this.nextCohortSize;
+    }
+    this.millisPerTick = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    this.unsubscribe = await client.queryMulti(
+      [
+        client.query.miningSlot.bidsForNextSlotCohort,
+        client.query.miningSlot.nextFrameId
+      ],
+      async ([bids, nextFrameId]) => {
+        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
+          await this.checkWinningBids(bids);
+        }
+      }
+    );
+  }
   async stop() {
-    if (this.isStopped) return this.stats;
+    if (this.isStopped) return this.winningBids;
     this.isStopped = true;
     console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
     clearTimeout(this.retryTimeout);
@@ -1783,79 +1741,47 @@ var CohortBidder = (_class11 = class {
     }
     void await this.pendingRequest;
     let header = await client.rpc.chain.getHeader();
+    let api = await client.at(header.hash);
     while (true) {
-      const api2 = await client.at(header.hash);
-      const cohortStartingFrameId = await api2.query.miningSlot.nextFrameId();
+      const cohortStartingFrameId = await api.query.miningSlot.nextFrameId();
       if (cohortStartingFrameId.toNumber() === this.cohortStartingFrameId) {
         break;
       }
       header = await client.rpc.chain.getHeader(header.parentHash);
+      api = await client.at(header.hash);
     }
-    const api = await client.at(header.hash);
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
     const bids = await api.query.miningSlot.bidsForNextSlotCohort();
-    this.history.trackChange(bids, header.number.toNumber(), tick, true);
+    this.updateSeatsWon(bids);
     console.log("Bidder stopped", {
       cohortStartingFrameId: this.cohortStartingFrameId,
       blockNumber: header.number.toNumber(),
-      tick,
-      bids: bids.map((x) => ({
-        address: x.accountId.toHuman(),
-        bid: x.bid.toBigInt()
-      }))
+      bids: this.winningBids
     });
-    return this.stats;
-  }
-  async start() {
-    console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
-      maxBid: formatArgons(this.options.maxBid),
-      minBid: formatArgons(this.options.minBid),
-      bidIncrement: formatArgons(this.options.bidIncrement),
-      maxBudget: formatArgons(this.options.maxBudget),
-      bidDelay: this.options.bidDelay,
-      subaccounts: this.subaccounts
-    });
-    const client = await this.client;
-    await this.history.init(client);
-    this.millisPerTick ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    this.unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.bidsForNextSlotCohort,
-        client.query.miningSlot.nextFrameId
-      ],
-      async ([bids, nextFrameId]) => {
-        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
-          await this.checkWinningBids(bids);
-        }
-      }
-    );
+    return this.winningBids;
   }
   async checkWinningBids(bids) {
     if (this.isStopped) return;
     clearTimeout(this.retryTimeout);
+    this.updateSeatsWon(bids);
+    const winningBids = this.winningBids.length;
+    this.needsRebid = winningBids < this.subaccounts.length;
     const client = await this.client;
     const bestBlock = await client.rpc.chain.getBlockHash();
     const api = await client.at(bestBlock);
     const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-    if (_optionalChain([this, 'access', _56 => _56.bidHistory, 'access', _57 => _57[0], 'optionalAccess', _58 => _58.blockNumber]) >= blockNumber) {
-      return;
-    }
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    const historyEntry = this.history.trackChange(bids, blockNumber, tick);
+    if (this.lastBidBlockNumber >= blockNumber) return;
     if (this.pendingRequest) return;
     const ticksSinceLastBid = Math.floor((Date.now() - this.lastBidTime) / this.millisPerTick);
-    if (ticksSinceLastBid < this.options.bidDelay) {
+    if (ticksSinceLastBid < this.options.bidDelay && this.needsRebid) {
       this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), this.millisPerTick);
       return;
     }
+    if (!this.needsRebid) return;
     console.log(
       "Checking bids for cohort",
       this.cohortStartingFrameId,
       this.subaccounts.map((x) => x.index)
     );
-    const winningBids = historyEntry.winningSeats;
-    this.needsRebid = winningBids < this.subaccounts.length;
-    if (!this.needsRebid) return;
     const winningAddresses = new Set(bids.map((x) => x.accountId.toHuman()));
     let lowestBid = -this.options.bidIncrement;
     if (bids.length) {
@@ -1866,7 +1792,6 @@ var CohortBidder = (_class11 = class {
         }
       }
     }
-    const MIN_INCREMENT = 10000n;
     let nextBid = lowestBid + this.options.bidIncrement;
     if (nextBid < this.options.minBid) {
       nextBid = this.options.minBid;
@@ -1895,10 +1820,9 @@ var CohortBidder = (_class11 = class {
       console.log(
         `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(lowestBid)}.`
       );
-      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
-    if (nextBid - lowestBid < MIN_INCREMENT) {
+    if (nextBid - lowestBid < Number(this.minIncrement)) {
       console.log(
         `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints.`,
         {
@@ -1907,14 +1831,11 @@ var CohortBidder = (_class11 = class {
           maxBid: formatArgons(this.options.maxBid)
         }
       );
-      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
     const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
     let accountsToUse = [...this.subaccounts];
     if (accountsToUse.length > seatsInBudget) {
-      const reason = availableBalanceForBids - feePlusTip < nextBid * BigInt(seatsInBudget) ? "InsufficientFunds" /* InsufficientFunds */ : "MaxBudgetTooLow" /* MaxBudgetTooLow */;
-      this.history.maybeReducingSeats(seatsInBudget, reason, historyEntry);
       accountsToUse.sort((a, b) => {
         const isWinningA = winningAddresses.has(a.address);
         const isWinningB = winningAddresses.has(b.address);
@@ -1927,19 +1848,11 @@ var CohortBidder = (_class11 = class {
       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, accountsToUse);
     }
     this.needsRebid = false;
   }
-  async bid(bidPerSeat, subaccounts, historyEntry) {
+  async bid(bidPerSeat, subaccounts) {
     const prevLastBidTime = this.lastBidTime;
     try {
       this.lastBidTime = Date.now();
@@ -1960,14 +1873,10 @@ var CohortBidder = (_class11 = class {
         blockNumber = await api.query.system.number().then((x) => x.toNumber());
       }
       const successfulBids = _nullishCoalesce(txResult.batchInterruptedIndex, () => ( subaccounts.length));
-      this.history.onBidResult(historyEntry, {
-        blockNumber,
-        successfulBids,
-        bidPerSeat,
-        txFeePlusTip: _nullishCoalesce(txResult.finalFee, () => ( 0n)),
-        bidsAttempted: subaccounts.length,
-        bidError
-      });
+      this.txFees += _nullishCoalesce(txResult.finalFee, () => ( 0n));
+      if (blockNumber !== void 0) {
+        this.lastBidBlockNumber = Math.max(blockNumber, this.lastBidBlockNumber);
+      }
       console.log("Done creating bids for cohort", {
         successfulBids,
         bidPerSeat,
@@ -1987,12 +1896,22 @@ var CohortBidder = (_class11 = class {
       await this.checkCurrentSeats();
     }
   }
+  updateSeatsWon(next) {
+    this.winningBids.length = 0;
+    for (const x of next) {
+      const bid = x.bid.toBigInt();
+      const address = x.accountId.toHuman();
+      if (this.myAddresses.has(address)) {
+        this.winningBids.push({ address, bid });
+      }
+    }
+  }
   async checkCurrentSeats() {
     const client = await this.client;
     const bids = await client.query.miningSlot.bidsForNextSlotCohort();
     await this.checkWinningBids(bids);
   }
-}, _class11);
+}, _class10);
 
 // src/BidPool.ts
 
@@ -2003,23 +1922,23 @@ var EMPTY_TABLE = {
   tableBottom: { left: " ", mid: " ", other: " ", right: " " },
   vertical: " "
 };
-var BidPool = (_class12 = class {
-  constructor(client, keypair, accountRegistry = AccountRegistry.factory()) {;_class12.prototype.__init28.call(this);_class12.prototype.__init29.call(this);_class12.prototype.__init30.call(this);_class12.prototype.__init31.call(this);_class12.prototype.__init32.call(this);_class12.prototype.__init33.call(this);
+var BidPool = (_class11 = class {
+  constructor(client, keypair, accountRegistry = AccountRegistry.factory()) {;_class11.prototype.__init27.call(this);_class11.prototype.__init28.call(this);_class11.prototype.__init29.call(this);_class11.prototype.__init30.call(this);_class11.prototype.__init31.call(this);_class11.prototype.__init32.call(this);
     this.client = client;
     this.keypair = keypair;
     this.accountRegistry = accountRegistry;
     this.blockWatch = new BlockWatch(client, { shouldLog: false });
   }
-  __init28() {this.bidPoolAmount = 0n}
-  __init29() {this.nextFrameId = 1}
-  __init30() {this.poolVaultCapitalByFrame = {}}
-  __init31() {this.vaultSecuritization = []}
+  __init27() {this.bidPoolAmount = 0n}
+  __init28() {this.nextFrameId = 1}
+  __init29() {this.poolVaultCapitalByFrame = {}}
+  __init30() {this.vaultSecuritization = []}
   
   
-  __init32() {this.vaultsById = {}}
+  __init31() {this.vaultsById = {}}
   
   
-  __init33() {this.FrameSubscriptions = {}}
+  __init32() {this.FrameSubscriptions = {}}
   async onVaultsUpdated(blockHash, vaultIdSet) {
     const client = await this.client;
     this.tickDuration ??= (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
@@ -2059,7 +1978,7 @@ var BidPool = (_class12 = class {
   }
   async loadAt(blockHash) {
     const client = await this.client;
-    blockHash ??= Buffer.from((await client.rpc.chain.getHeader()).hash);
+    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());
@@ -2325,9 +2244,10 @@ Raising Funds (Frame ${this.nextFrameId + 1}):`);
       });
     }
   }
-}, _class12);
+}, _class11);
 
 // src/BitcoinLocks.ts
+
 var SATS_PER_BTC = 100000000n;
 var BitcoinLocks = class _BitcoinLocks {
   constructor(client) {
@@ -2387,7 +2307,7 @@ var BitcoinLocks = class _BitcoinLocks {
   async getUtxoRef(utxoId, atHeight) {
     let client = await this.client;
     if (atHeight !== void 0) {
-      const blockHash = await client.query.system.blockHash(atHeight);
+      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
       client = await client.at(blockHash);
     }
     const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
@@ -2395,15 +2315,15 @@ var BitcoinLocks = class _BitcoinLocks {
       return;
     }
     const ref = refRaw.unwrap();
-    const txid = Buffer.from(ref.txid).toString("hex");
-    const btcTxid = Buffer.from(ref.txid.reverse()).toString("hex");
+    const txid = _util.u8aToHex.call(void 0, ref.txid);
+    const bitcoinTxid = _util.u8aToHex.call(void 0, ref.txid.reverse());
     const vout = ref.outputIndex.toNumber();
-    return { txid: `0x${txid}`, vout, bitcoinTxid: `0x${btcTxid}` };
+    return { txid, vout, bitcoinTxid };
   }
   async getReleaseRequest(utxoId, atHeight) {
     let client = await this.client;
     if (atHeight !== void 0) {
-      const blockHash = await client.query.system.blockHash(atHeight);
+      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
       client = await client.at(blockHash);
     }
     const locksPendingRelease = await client.query.bitcoinLocks.locksPendingReleaseByUtxoId();
@@ -2423,15 +2343,15 @@ var BitcoinLocks = class _BitcoinLocks {
   async submitVaultSignature(args) {
     const { utxoId, vaultSignature, argonKeyring } = args;
     const client = await this.client;
-    if (!vaultSignature || vaultSignature.byteLength < 71 || vaultSignature.byteLength > 73) {
+    if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
       throw new Error(
-        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 71-73 bytes.`
+        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
       );
     }
-    const signature = `0x${vaultSignature.toString("hex")}`;
+    const signature = _util.u8aToHex.call(void 0, vaultSignature);
     const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
     const submitter = new TxSubmitter(client, tx, argonKeyring);
-    return await submitter.submit({ waitForBlock: true });
+    return await submitter.submit();
   }
   async getBitcoinLock(utxoId) {
     const client = await this.client;
@@ -2452,7 +2372,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const ownerPubkey = utxo.ownerPubkey.toHex();
     const [fingerprint, cosign_hd_index, claim_hd_index] = utxo.vaultXpubSources;
     const vaultXpubSources = {
-      parentFingerprint: Buffer.from(fingerprint),
+      parentFingerprint: new Uint8Array(fingerprint),
       cosignHdIndex: cosign_hd_index.toNumber(),
       claimHdIndex: claim_hd_index.toNumber()
     };
@@ -2534,7 +2454,7 @@ var BitcoinLocks = class _BitcoinLocks {
         await new Promise((resolve) => setTimeout(resolve, 1e3));
         continue;
       }
-      const hash = await client.query.system.blockHash(atHeight).then((x) => x.toHex());
+      const hash = await client.rpc.chain.getBlockHash(atHeight).then((x) => x.toHex());
       if (hash === "0x0000000000000000000000000000000000000000000000000000000000000000") {
         console.warn(`Block hash not found for height ${atHeight}. Retrying...`);
         await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -2556,7 +2476,7 @@ var BitcoinLocks = class _BitcoinLocks {
       if (client.events.bitcoinLocks.BitcoinUtxoCosigned.is(event.event)) {
         const { utxoId: id, signature } = event.event.data;
         if (id.toNumber() === utxoId) {
-          return Buffer.from(signature);
+          return new Uint8Array(signature);
         }
       }
     }
@@ -2744,7 +2664,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const vaults = new VaultMonitor(accountset, {
       bitcoinSpaceAvailable: argonAmount
     });
-    const bitcoinXpubBuffer = Buffer.from(bitcoinXpub.replace(/^0x(.+)/, "$1"), "hex");
+    const bitcoinXpubBuffer = _util.hexToU8a.call(void 0, bitcoinXpub);
     return new Promise(async (resolve, reject) => {
       vaults.events.on("bitcoin-space-above", async (vaultId, amount) => {
         const vault = vaults.vaultsById[vaultId];
@@ -2801,9 +2721,32 @@ function createKeyringPair(opts) {
 }
 
 // src/index.ts
-var _types = require('@polkadot/types'); _createStarExport(_types);
-var _interfaces = require('@polkadot/types/interfaces'); _createStarExport(_interfaces);
-var _types3 = require('@polkadot/types-codec/types'); _createStarExport(_types3);
+
+var _generic = require('@polkadot/types/generic');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _typescodec = require('@polkadot/types-codec');
 async function waitForLoad() {
   await _utilcrypto.cryptoWaitReady.call(void 0, );
 }
@@ -2861,5 +2804,34 @@ async function getClient(host) {
 
 
 
-exports.WageProtector = WageProtector; exports.TxSubmitter = TxSubmitter; exports.MICROGONS_PER_ARGON = MICROGONS_PER_ARGON; exports.formatArgons = formatArgons; exports.formatPercent = formatPercent; exports.filterUndefined = filterUndefined; exports.gettersToObject = gettersToObject; exports.toFixedNumber = toFixedNumber; exports.convertNumberToFixedU128 = convertNumberToFixedU128; exports.convertFixedU128ToBigNumber = convertFixedU128ToBigNumber; exports.convertPermillToBigNumber = convertPermillToBigNumber; exports.convertNumberToPermill = convertNumberToPermill; exports.eventDataToJson = eventDataToJson; exports.dispatchErrorToString = dispatchErrorToString; exports.ExtrinsicError = ExtrinsicError2; exports.dispatchErrorToExtrinsicError = dispatchErrorToExtrinsicError; exports.checkForExtrinsicSuccess = checkForExtrinsicSuccess; exports.JsonExt = JsonExt; exports.createNanoEvents = createNanoEvents; exports.TypedEmitter = TypedEmitter; exports.AccountRegistry = AccountRegistry; exports.getTickFromHeader = getTickFromHeader; exports.getAuthorFromHeader = getAuthorFromHeader; exports.BlockWatch = BlockWatch; exports.FrameCalculator = FrameCalculator; exports.AccountMiners = AccountMiners; exports.Accountset = Accountset; exports.parseSubaccountRange = parseSubaccountRange; exports.MiningBids = MiningBids; exports.Vault = Vault; exports.VaultMonitor = VaultMonitor; exports.CohortBidderHistory = CohortBidderHistory; exports.CohortBidder = CohortBidder; exports.BidPool = BidPool; exports.SATS_PER_BTC = SATS_PER_BTC; exports.BitcoinLocks = BitcoinLocks; exports.keyringFromSuri = keyringFromSuri; exports.createKeyringPair = createKeyringPair; exports.Keyring = _api.Keyring; exports.decodeAddress = _utilcrypto.decodeAddress; exports.mnemonicGenerate = _utilcrypto.mnemonicGenerate; exports.waitForLoad = waitForLoad; exports.getClient = getClient;
-//# sourceMappingURL=chunk-SHAEHPI5.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.WageProtector = WageProtector; exports.setConfig = setConfig; exports.getConfig = getConfig; exports.TxSubmitter = TxSubmitter; exports.MICROGONS_PER_ARGON = MICROGONS_PER_ARGON; exports.formatArgons = formatArgons; exports.formatPercent = formatPercent; exports.filterUndefined = filterUndefined; exports.gettersToObject = gettersToObject; exports.toFixedNumber = toFixedNumber; exports.convertNumberToFixedU128 = convertNumberToFixedU128; exports.convertFixedU128ToBigNumber = convertFixedU128ToBigNumber; exports.convertPermillToBigNumber = convertPermillToBigNumber; exports.convertNumberToPermill = convertNumberToPermill; exports.eventDataToJson = eventDataToJson; exports.dispatchErrorToString = dispatchErrorToString; exports.ExtrinsicError = ExtrinsicError2; exports.dispatchErrorToExtrinsicError = dispatchErrorToExtrinsicError; exports.checkForExtrinsicSuccess = checkForExtrinsicSuccess; exports.JsonExt = JsonExt; exports.createNanoEvents = createNanoEvents; exports.TypedEmitter = TypedEmitter; exports.AccountRegistry = AccountRegistry; exports.getTickFromHeader = getTickFromHeader; exports.getAuthorFromHeader = getAuthorFromHeader; exports.BlockWatch = BlockWatch; exports.FrameCalculator = FrameCalculator; exports.AccountMiners = AccountMiners; exports.Accountset = Accountset; exports.parseSubaccountRange = parseSubaccountRange; exports.MiningBids = MiningBids; exports.Vault = Vault; exports.VaultMonitor = VaultMonitor; exports.CohortBidder = CohortBidder; exports.BidPool = BidPool; exports.SATS_PER_BTC = SATS_PER_BTC; exports.BitcoinLocks = BitcoinLocks; exports.keyringFromSuri = keyringFromSuri; exports.createKeyringPair = createKeyringPair; exports.Keyring = _api.Keyring; exports.decodeAddress = _utilcrypto.decodeAddress; exports.mnemonicGenerate = _utilcrypto.mnemonicGenerate; exports.waitForLoad = waitForLoad; exports.getClient = getClient; exports.u8aToHex = _util.u8aToHex; exports.hexToU8a = _util.hexToU8a; exports.u8aEq = _util.u8aEq; exports.GenericEvent = _generic.GenericEvent; exports.GenericBlock = _generic.GenericBlock; exports.GenericAddress = _generic.GenericAddress; exports.BTreeMap = _typescodec.BTreeMap; exports.Bytes = _typescodec.Bytes; exports.Compact = _typescodec.Compact; exports.Enum = _typescodec.Enum; exports.Null = _typescodec.Null; exports.Option = _typescodec.Option; exports.Result = _typescodec.Result; exports.Bool = _typescodec.Bool; exports.Tuple = _typescodec.Tuple; exports.Range = _typescodec.Range; exports.Struct = _typescodec.Struct; exports.Text = _typescodec.Text; exports.U256 = _typescodec.U256; exports.U8aFixed = _typescodec.U8aFixed; exports.Vec = _typescodec.Vec; exports.bool = _typescodec.bool; exports.i128 = _typescodec.i128; exports.u128 = _typescodec.u128; exports.u16 = _typescodec.u16; exports.u32 = _typescodec.u32; exports.u64 = _typescodec.u64; exports.u8 = _typescodec.u8;
+//# sourceMappingURL=chunk-OFYVHBKG.cjs.map