@argonprotocol/mainchain 1.3.4 → 1.3.6

package/lib/{chunk-W5SOPU7I.cjs → chunk-U6J3AWYW.cjs}

@@ -261,10 +261,10 @@ var TxResult = (_class = class {
 var _bignumberjs = require('bignumber.js'); var BN = _interopRequireWildcard(_bignumberjs); var BN2 = _interopRequireWildcard(_bignumberjs);
 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 = BN.default.call(void 0, x.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+function formatArgons(microgons) {
+  if (microgons === void 0 || microgons === null) return "na";
+  const isNegative = microgons < 0;
+  let format = BN.default.call(void 0, microgons.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
   if (format.endsWith(".00")) {
     format = format.slice(0, -3);
   }
@@ -637,9 +637,13 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
 }, _class4);
 
 // src/FrameCalculator.ts
-var FrameCalculator = class {
+var FrameCalculator = class _FrameCalculator {
   
   
+  
+  async load(client) {
+    return await this.getConfig(client);
+  }
   async getForTick(client, tick) {
     const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
     const ticksSinceMiningStart = tick - biddingStartTick;
@@ -647,9 +651,10 @@ var FrameCalculator = class {
   }
   async getTickRangeForFrame(client, frameId) {
     const { ticksBetweenFrames, biddingStartTick } = await this.getConfig(client);
-    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
-    const endingTick = startingTick + ticksBetweenFrames - 1;
-    return [startingTick, endingTick];
+    return _FrameCalculator.calculateTickRangeForFrame(frameId, {
+      ticksBetweenFrames,
+      biddingStartTick
+    });
   }
   async getForHeader(client, header) {
     if (header.number.toNumber() === 0) return 0;
@@ -657,18 +662,30 @@ var FrameCalculator = class {
     if (tick === void 0) return void 0;
     return this.getForTick(client, tick);
   }
+  static frameToDateRange(frameId, config2) {
+    const [start, end] = _FrameCalculator.calculateTickRangeForFrame(frameId, config2);
+    return [new Date(start * config2.tickMillis), new Date(end * config2.tickMillis)];
+  }
+  static calculateTickRangeForFrame(frameId, config2) {
+    const { ticksBetweenFrames, biddingStartTick } = config2;
+    const startingTick = biddingStartTick + Math.floor(frameId * ticksBetweenFrames);
+    const endingTick = startingTick + ticksBetweenFrames - 1;
+    return [startingTick, endingTick];
+  }
   async getConfig(client) {
     this.miningConfig ??= await client.query.miningSlot.miningConfig().then((x) => ({
       ticksBetweenSlots: x.ticksBetweenSlots.toNumber(),
       slotBiddingStartAfterTicks: x.slotBiddingStartAfterTicks.toNumber()
     }));
     this.genesisTick ??= await client.query.ticks.genesisTick().then((x) => x.toNumber());
+    this.tickMillis ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
     const config2 = this.miningConfig;
     const genesisTick = this.genesisTick;
     return {
       ticksBetweenFrames: config2.ticksBetweenSlots,
       slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
       genesisTick,
+      tickMillis: this.tickMillis,
       biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
     };
   }
@@ -1656,31 +1673,37 @@ var VaultMonitor = (_class8 = class {
 
 // src/CohortBidder.ts
 var CohortBidder = (_class9 = class {
-  constructor(accountset, cohortStartingFrameId, subaccounts, options) {;_class9.prototype.__init18.call(this);_class9.prototype.__init19.call(this);_class9.prototype.__init20.call(this);_class9.prototype.__init21.call(this);_class9.prototype.__init22.call(this);_class9.prototype.__init23.call(this);_class9.prototype.__init24.call(this);_class9.prototype.__init25.call(this);
+  constructor(accountset, cohortStartingFrameId, subaccounts, options, callbacks) {;_class9.prototype.__init18.call(this);_class9.prototype.__init19.call(this);_class9.prototype.__init20.call(this);_class9.prototype.__init21.call(this);_class9.prototype.__init22.call(this);_class9.prototype.__init23.call(this);_class9.prototype.__init24.call(this);_class9.prototype.__init25.call(this);
     this.accountset = accountset;
     this.cohortStartingFrameId = cohortStartingFrameId;
     this.subaccounts = subaccounts;
     this.options = options;
+    this.callbacks = callbacks;
     this.subaccounts.forEach((x) => {
       this.myAddresses.add(x.address);
     });
   }
-  get client() {
+  get clientPromise() {
     return this.accountset.client;
   }
   __init18() {this.txFees = 0n}
-  __init19() {this.winningBids = []}
+  __init19() {this.bidsAttempted = 0}
+  __init20() {this.winningBids = []}
+  __init21() {this.myAddresses = /* @__PURE__ */ new Set()}
+  __init22() {this.currentBids = {
+    bids: [],
+    mostRecentBidTick: 0,
+    atTick: 0,
+    atBlockNumber: 0
+  }}
   
   
+  __init23() {this.isStopped = false}
   
-  __init20() {this.isStopped = false}
-  __init21() {this.needsRebid = false}
-  __init22() {this.lastBidTime = 0}
+  __init24() {this.minIncrement = 10000n}
   
-  __init23() {this.minIncrement = 10000n}
+  __init25() {this.lastBidTick = 0}
   
-  __init24() {this.lastBidBlockNumber = 0}
-  __init25() {this.myAddresses = /* @__PURE__ */ new Set()}
   async start() {
     console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
       maxBid: formatArgons(this.options.maxBid),
@@ -1690,7 +1713,7 @@ var CohortBidder = (_class9 = class {
       bidDelay: this.options.bidDelay,
       subaccounts: this.subaccounts
     });
-    const client = await this.client;
+    const client = await this.clientPromise;
     this.minIncrement = client.consts.miningSlot.bidIncrements.toBigInt();
     this.nextCohortSize = await client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
     if (this.subaccounts.length > this.nextCohortSize) {
@@ -1700,14 +1723,22 @@ var CohortBidder = (_class9 = class {
       this.subaccounts.length = this.nextCohortSize;
     }
     this.millisPerTick = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    let didStart = false;
     this.unsubscribe = await client.queryMulti(
       [
         client.query.miningSlot.bidsForNextSlotCohort,
-        client.query.miningSlot.nextFrameId
+        client.query.miningSlot.nextFrameId,
+        client.query.ticks.currentTick,
+        client.query.system.number
       ],
-      async ([bids, nextFrameId]) => {
+      async ([rawBids, nextFrameId, currentTick, blockNumber]) => {
         if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
-          await this.checkWinningBids(bids);
+          this.updateBidList(rawBids, blockNumber.toNumber(), currentTick.toNumber());
+          if (!didStart) {
+            didStart = true;
+            this.scheduleEvaluation();
+            void this.checkWinningBids();
+          }
         }
       }
     );
@@ -1715,12 +1746,12 @@ var CohortBidder = (_class9 = class {
   async stop() {
     if (this.isStopped) return this.winningBids;
     this.isStopped = true;
+    clearInterval(this.evaluateInterval);
     console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
-    clearTimeout(this.retryTimeout);
     if (this.unsubscribe) {
       this.unsubscribe();
     }
-    const client = await this.client;
+    const client = await this.clientPromise;
     const [nextFrameId, isBiddingOpen] = await client.queryMulti([
       client.query.miningSlot.nextFrameId,
       client.query.miningSlot.isNextSlotBiddingOpen
@@ -1737,58 +1768,63 @@ var CohortBidder = (_class9 = class {
       });
     }
     void await this.pendingRequest;
-    let header = await client.rpc.chain.getHeader();
-    let api = await client.at(header.hash);
-    while (true) {
-      const cohortStartingFrameId = await api.query.miningSlot.nextFrameId();
-      if (cohortStartingFrameId.toNumber() === this.cohortStartingFrameId) {
-        break;
-      }
-      header = await client.rpc.chain.getHeader(header.parentHash);
-      api = await client.at(header.hash);
+    const currentFrameId = await client.query.miningSlot.nextFrameId();
+    let blockNumber;
+    if (currentFrameId.toNumber() > this.cohortStartingFrameId) {
+      blockNumber = await client.query.miningSlot.frameStartBlockNumbers().then((x) => _optionalChain([x, 'access', _56 => _56[0], 'optionalAccess', _57 => _57.toNumber, 'call', _58 => _58()])) - 1;
+    } else {
+      blockNumber = await client.query.system.number().then((x) => x.toNumber());
     }
-    const bids = await api.query.miningSlot.bidsForNextSlotCohort();
-    this.updateSeatsWon(bids);
+    const blockHash = await client.query.system.blockHash(blockNumber);
+    const api = await client.at(blockHash);
+    const rawBids = await api.query.miningSlot.bidsForNextSlotCohort();
+    const currentTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
+    this.updateBidList(rawBids, blockNumber, currentTick);
     console.log("Bidder stopped", {
       cohortStartingFrameId: this.cohortStartingFrameId,
-      blockNumber: header.number.toNumber(),
-      bids: this.winningBids
+      blockNumber,
+      winningBids: this.winningBids
     });
     return this.winningBids;
   }
-  async checkWinningBids(bids) {
+  async checkWinningBids() {
     if (this.isStopped) return;
-    clearTimeout(this.retryTimeout);
-    this.updateSeatsWon(bids);
-    const winningBids = this.winningBids.length;
-    this.needsRebid = winningBids < this.subaccounts.length;
-    const client = await this.client;
-    const bestBlock = await client.rpc.chain.getBlockHash();
-    const api = await client.at(bestBlock);
-    const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-    if (this.lastBidBlockNumber >= blockNumber) return;
-    if (this.pendingRequest) return;
-    const ticksSinceLastBid = Math.floor((Date.now() - this.lastBidTime) / this.millisPerTick);
-    if (ticksSinceLastBid < this.options.bidDelay && this.needsRebid) {
-      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), this.millisPerTick);
+    if (this.pendingRequest) {
+      console.log("Current bid is still in progress, skipping this check");
+      return;
+    }
+    if (this.currentBids.mostRecentBidTick < this.lastBidTick) {
+      console.log(`Waiting for bids more recent than our last attempt.`, {
+        ownAttemptedBidTick: this.lastBidTick,
+        liveBidsTick: this.currentBids.mostRecentBidTick
+      });
+      return;
+    }
+    const bids = [...this.currentBids.bids];
+    const bidsAtTick = this.currentBids.atTick;
+    const blockNumber = this.currentBids.atBlockNumber;
+    const winningBids = bids.filter((x) => this.myAddresses.has(x.address));
+    if (winningBids.length >= this.subaccounts.length) {
+      console.log(`No updates needed. Winning all remaining seats (${winningBids.length}).`);
       return;
     }
-    if (!this.needsRebid) return;
     console.log(
-      "Checking bids for cohort",
-      this.cohortStartingFrameId,
-      this.subaccounts.map((x) => x.index)
+      `Checking bids for cohort ${this.cohortStartingFrameId}, Still trying for seats: ${this.subaccounts.length}`
     );
-    const winningAddresses = new Set(bids.map((x) => x.accountId.toHuman()));
-    let lowestBid = -this.options.bidIncrement;
-    if (bids.length) {
-      for (let i = bids.length - 1; i >= 0; i--) {
-        if (!this.myAddresses.has(bids[i].accountId.toHuman())) {
-          lowestBid = bids.at(i).bid.toBigInt();
-          break;
+    const winningAddresses = new Set(winningBids.map((x) => x.address));
+    let lowestBid;
+    let myAllocatedBids = 0n;
+    for (const bid of bids) {
+      lowestBid ??= bid.bidMicrogons;
+      if (this.myAddresses.has(bid.address)) {
+        myAllocatedBids += bid.bidMicrogons;
+      } else {
+        if (bid.bidMicrogons < lowestBid) {
+          lowestBid = bid.bidMicrogons;
         }
       }
     }
+    lowestBid ??= -this.options.bidIncrement;
     let nextBid = lowestBid + this.options.bidIncrement;
     if (nextBid < this.options.minBid) {
       nextBid = this.options.minBid;
@@ -1800,39 +1836,59 @@ var CohortBidder = (_class9 = class {
       subaccounts: this.subaccounts,
       bidAmount: nextBid
     });
-    let availableBalanceForBids = await api.query.system.account(this.accountset.txSubmitterPair.address).then((x) => x.data.free.toBigInt());
-    for (const bid of bids) {
-      if (this.myAddresses.has(bid.accountId.toHuman())) {
-        availableBalanceForBids += bid.bid.toBigInt();
-      }
-    }
+    let availableBalanceForBids = await this.accountset.submitterBalance();
+    availableBalanceForBids += myAllocatedBids;
     const tip = _nullishCoalesce(this.options.tipPerTransaction, () => ( 0n));
     const feeEstimate = await fakeTx.feeEstimate(tip);
-    const feePlusTip = feeEstimate + tip;
-    let budgetForSeats = this.options.maxBudget - feePlusTip;
+    const estimatedFeePlusTip = feeEstimate + tip;
+    let budgetForSeats = this.options.maxBudget - estimatedFeePlusTip;
     if (budgetForSeats > availableBalanceForBids) {
-      budgetForSeats = availableBalanceForBids - feePlusTip;
+      budgetForSeats = availableBalanceForBids - estimatedFeePlusTip;
     }
     if (nextBid < lowestBid) {
       console.log(
-        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(lowestBid)}.`
+        `Next bid within parameters is ${formatArgons(nextBid)}, but it's not enough. Current lowest bid is ${formatArgons(lowestBid)}.`
       );
+      this.safeRecordParamsAdjusted({
+        tick: bidsAtTick,
+        blockNumber,
+        maxSeats: 0,
+        winningBidCount: winningBids.length,
+        reason: "max-bid-too-low",
+        availableBalanceForBids
+      });
       return;
     }
     if (nextBid - lowestBid < Number(this.minIncrement)) {
       console.log(
-        `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints.`,
+        `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints (next bid below min increment).`,
         {
           lowestCurrentBid: formatArgons(lowestBid),
           nextAttemptedBid: formatArgons(nextBid),
           maxBid: formatArgons(this.options.maxBid)
         }
       );
+      this.safeRecordParamsAdjusted({
+        tick: bidsAtTick,
+        blockNumber,
+        maxSeats: 0,
+        winningBidCount: winningBids.length,
+        reason: "max-bid-too-low",
+        availableBalanceForBids
+      });
       return;
     }
     const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
     let accountsToUse = [...this.subaccounts];
     if (accountsToUse.length > seatsInBudget) {
+      this.safeRecordParamsAdjusted({
+        tick: bidsAtTick,
+        blockNumber,
+        maxSeats: this.subaccounts.length,
+        winningBidCount: winningBids.length,
+        reason: availableBalanceForBids - estimatedFeePlusTip < nextBid * BigInt(seatsInBudget) ? "insufficient-balance" : "max-budget-too-low",
+        availableBalanceForBids
+      });
       accountsToUse.sort((a, b) => {
         const isWinningA = winningAddresses.has(a.address);
         const isWinningB = winningAddresses.has(b.address);
@@ -1844,18 +1900,16 @@ var CohortBidder = (_class9 = class {
       });
       accountsToUse.length = seatsInBudget;
     }
-    if (accountsToUse.length > winningBids) {
-      this.pendingRequest = this.bid(nextBid, accountsToUse);
+    if (accountsToUse.length > winningBids.length) {
+      this.pendingRequest = this.submitBids(nextBid, accountsToUse);
     }
-    this.needsRebid = false;
   }
-  async bid(bidPerSeat, subaccounts) {
-    const prevLastBidTime = this.lastBidTime;
+  async submitBids(microgonsPerSeat, subaccounts) {
     try {
-      this.lastBidTime = Date.now();
+      this.bidsAttempted += subaccounts.length;
       const submitter = await this.accountset.createMiningBidTx({
         subaccounts,
-        bidAmount: bidPerSeat
+        bidAmount: microgonsPerSeat
       });
       const tip = _nullishCoalesce(this.options.tipPerTransaction, () => ( 0n));
       const txResult = await submitter.submit({
@@ -1863,50 +1917,108 @@ var CohortBidder = (_class9 = class {
         useLatestNonce: true
       });
       const bidError = await txResult.inBlockPromise.then(() => void 0).catch((x) => x);
-      let blockNumber;
-      if (txResult.includedInBlock) {
-        const client = await this.client;
-        const api = await client.at(txResult.includedInBlock);
-        blockNumber = await api.query.system.number().then((x) => x.toNumber());
+      const client = await this.clientPromise;
+      let api = txResult.includedInBlock ? await client.at(txResult.includedInBlock) : client;
+      this.lastBidTick = await api.query.ticks.currentTick().then((x) => x.toNumber());
+      const blockNumber = await api.query.system.number().then((x) => x.toNumber());
+      const bidAtTick = this.lastBidTick;
+      try {
+        _optionalChain([this, 'access', _59 => _59.callbacks, 'optionalAccess', _60 => _60.onBidsSubmitted, 'optionalCall', _61 => _61({
+          tick: bidAtTick,
+          blockNumber,
+          microgonsPerSeat,
+          txFeePlusTip: _nullishCoalesce(txResult.finalFee, () => ( 0n)),
+          submittedCount: subaccounts.length
+        })]);
+      } catch (error) {
+        console.error("Error in onBidsSubmitted callback:", error);
       }
       const successfulBids = _nullishCoalesce(txResult.batchInterruptedIndex, () => ( subaccounts.length));
       this.txFees += _nullishCoalesce(txResult.finalFee, () => ( 0n));
-      if (blockNumber !== void 0) {
-        this.lastBidBlockNumber = Math.max(blockNumber, this.lastBidBlockNumber);
-      }
-      console.log("Done creating bids for cohort", {
+      console.log("Result of bids for cohort", {
         successfulBids,
-        bidPerSeat,
-        blockNumber
+        bidsPlaced: subaccounts.length,
+        bidPerSeat: formatArgons(microgonsPerSeat),
+        bidAtTick
       });
-      if (bidError) throw bidError;
+      if (bidError) {
+        try {
+          _optionalChain([this, 'access', _62 => _62.callbacks, 'optionalAccess', _63 => _63.onBidsRejected, 'optionalCall', _64 => _64({
+            tick: bidAtTick,
+            blockNumber,
+            microgonsPerSeat,
+            submittedCount: subaccounts.length,
+            rejectedCount: subaccounts.length - successfulBids,
+            bidError
+          })]);
+        } catch (error) {
+          console.error("Error in onBidsRejected callback:", error);
+        }
+        throw bidError;
+      }
     } catch (err) {
-      this.lastBidTime = prevLastBidTime;
       console.error(`Error bidding for cohort ${this.cohortStartingFrameId}:`, err);
-      clearTimeout(this.retryTimeout);
-      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), 1e3);
     } finally {
       this.pendingRequest = void 0;
-    }
-    if (this.needsRebid) {
-      this.needsRebid = false;
-      await this.checkCurrentSeats();
+      this.scheduleEvaluation();
     }
   }
-  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 });
+  scheduleEvaluation() {
+    const millisPerTick = this.millisPerTick;
+    const delayTicks = Math.max(this.options.bidDelay, 1);
+    const delay = delayTicks * millisPerTick;
+    if (this.evaluateInterval) clearInterval(this.evaluateInterval);
+    console.log(`Scheduling next evaluation in ${delay}ms`);
+    this.evaluateInterval = setInterval(() => this.checkWinningBids().catch(console.error), delay);
+  }
+  updateBidList(rawBids, blockNumber, tick) {
+    try {
+      let mostRecentBidTick = 0;
+      let hasDiffs = this.currentBids.bids.length !== rawBids.length;
+      const bids = [];
+      for (let i = 0; i < rawBids.length; i += 1) {
+        const rawBid = rawBids[i];
+        const bidAtTick = rawBid.bidAtTick.toNumber();
+        if (bidAtTick > mostRecentBidTick) {
+          mostRecentBidTick = bidAtTick;
+        }
+        const address = rawBid.accountId.toHuman();
+        const bidMicrogons = rawBid.bid.toBigInt();
+        if (!hasDiffs) {
+          const existing = this.currentBids.bids[i];
+          hasDiffs = _optionalChain([existing, 'optionalAccess', _65 => _65.address]) !== address || _optionalChain([existing, 'optionalAccess', _66 => _66.bidMicrogons]) !== bidMicrogons;
+        }
+        bids.push({
+          address,
+          bidMicrogons,
+          bidAtTick
+        });
+      }
+      if (blockNumber > this.currentBids.atBlockNumber && hasDiffs) {
+        this.currentBids.bids = bids;
+        this.currentBids.mostRecentBidTick = mostRecentBidTick;
+        this.currentBids.atTick = tick;
+        this.currentBids.atBlockNumber = blockNumber;
+        this.winningBids = bids.filter((x) => this.myAddresses.has(x.address));
+        console.log("Now winning bids:", this.winningBids.length);
+        if (_optionalChain([this, 'access', _67 => _67.callbacks, 'optionalAccess', _68 => _68.onBidsUpdated])) {
+          this.callbacks.onBidsUpdated({
+            bids: this.winningBids,
+            atBlockNumber: blockNumber,
+            tick: mostRecentBidTick
+          });
+        }
       }
+    } catch (err) {
+      console.error("Error processing updated bids list:", err);
     }
   }
-  async checkCurrentSeats() {
-    const client = await this.client;
-    const bids = await client.query.miningSlot.bidsForNextSlotCohort();
-    await this.checkWinningBids(bids);
+  safeRecordParamsAdjusted(args) {
+    try {
+      _optionalChain([this, 'access', _69 => _69.callbacks, 'optionalAccess', _70 => _70.onBidParamsAdjusted, 'optionalCall', _71 => _71(args)]);
+    } catch (err) {
+      console.error("Error in onBidParamsAdjusted callback:", err);
+    }
   }
 }, _class9);
 
@@ -2009,7 +2121,7 @@ var BidPool = (_class10 = class {
         const { frameId: rawFrameId } = event.data;
         this.lastDistributedFrameId = rawFrameId.toNumber();
         this.bidPoolAmount = await this.getBidPool();
-        _optionalChain([this, 'access', _56 => _56.FrameSubscriptions, 'access', _57 => _57[rawFrameId.toNumber()], 'optionalCall', _58 => _58()]);
+        _optionalChain([this, 'access', _72 => _72.FrameSubscriptions, 'access', _73 => _73[rawFrameId.toNumber()], 'optionalCall', _74 => _74()]);
         const entrant = await api.query.liquidityPools.vaultPoolsByFrame(rawFrameId);
         this.loadFrameData(rawFrameId.toNumber(), entrant);
         this.printDebounce();
@@ -2055,7 +2167,7 @@ var BidPool = (_class10 = class {
     const tx = client.tx.liquidityPools.bondArgons(vaultId, amount);
     const txSubmitter = new TxSubmitter(client, tx, this.keypair);
     const affordability = await txSubmitter.canAfford({
-      tip: _optionalChain([options, 'optionalAccess', _59 => _59.tip]),
+      tip: _optionalChain([options, 'optionalAccess', _75 => _75.tip]),
       unavailableBalance: amount
     });
     if (!affordability.canAfford) {
@@ -2066,7 +2178,7 @@ var BidPool = (_class10 = class {
       throw new Error("Insufficient balance to bond argons to liquidity pool");
     }
     const result = await txSubmitter.submit({
-      tip: _optionalChain([options, 'optionalAccess', _60 => _60.tip]),
+      tip: _optionalChain([options, 'optionalAccess', _76 => _76.tip]),
       useLatestNonce: true
     });
     await result.inBlockPromise;
@@ -2195,7 +2307,7 @@ Raising Funds (Frame ${this.nextFrameId + 1}):`);
     this.poolVaultCapitalByFrame ??= {};
     this.poolVaultCapitalByFrame[frameId] ??= {};
     this.poolVaultCapitalByFrame[frameId][vaultId] ??= {
-      activatedCapital: _nullishCoalesce(_nullishCoalesce(data.activatedCapital, () => ( _optionalChain([data, 'access', _61 => _61.contributors, 'optionalAccess', _62 => _62.reduce, 'call', _63 => _63((a, b) => a + b.amount, 0n)]))), () => ( 0n))
+      activatedCapital: _nullishCoalesce(_nullishCoalesce(data.activatedCapital, () => ( _optionalChain([data, 'access', _77 => _77.contributors, 'optionalAccess', _78 => _78.reduce, 'call', _79 => _79((a, b) => a + b.amount, 0n)]))), () => ( 0n))
     };
     Object.assign(this.poolVaultCapitalByFrame[frameId][vaultId], filterUndefined(data));
   }
@@ -2283,7 +2395,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const client = await this.client;
     const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
     return {
-      releaseExpirationBlocks: client.consts.bitcoinLocks.lockReleaseCosignDeadlineBlocks.toNumber(),
+      lockReleaseCosignDeadlineFrames: client.consts.bitcoinLocks.lockReleaseCosignDeadlineFrames.toNumber(),
       pendingConfirmationExpirationBlocks: client.consts.bitcoinUtxos.maxPendingConfirmationBlocks.toNumber(),
       tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
       bitcoinNetwork
@@ -2291,7 +2403,7 @@ var BitcoinLocks = class _BitcoinLocks {
   }
   async getBitcoinConfirmedBlockHeight() {
     const client = await this.client;
-    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _64 => _64.value, 'optionalAccess', _65 => _65.blockHeight, 'access', _66 => _66.toNumber, 'call', _67 => _67()]), () => ( 0)));
+    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _80 => _80.value, 'optionalAccess', _81 => _81.blockHeight, 'access', _82 => _82.toNumber, 'call', _83 => _83()]), () => ( 0)));
   }
   /**
    * Gets the UTXO reference by ID.
@@ -2324,19 +2436,18 @@ var BitcoinLocks = class _BitcoinLocks {
       const blockHash = await client.rpc.chain.getBlockHash(atHeight);
       client = await client.at(blockHash);
     }
-    const locksPendingRelease = await client.query.bitcoinLocks.locksPendingReleaseByUtxoId();
-    for (const [id, request] of locksPendingRelease.entries()) {
-      if (id.toNumber() === utxoId) {
-        return {
-          toScriptPubkey: request.toScriptPubkey.toHex(),
-          bitcoinNetworkFee: request.bitcoinNetworkFee.toBigInt(),
-          dueBlockHeight: request.cosignDueBlock.toNumber(),
-          vaultId: request.vaultId.toNumber(),
-          redemptionPrice: request.redemptionPrice.toBigInt()
-        };
-      }
+    const requestMaybe = await client.query.bitcoinLocks.lockReleaseRequestsByUtxoId(utxoId);
+    if (!requestMaybe.isSome) {
+      return void 0;
     }
-    return void 0;
+    const request = requestMaybe.unwrap();
+    return {
+      toScriptPubkey: request.toScriptPubkey.toHex(),
+      bitcoinNetworkFee: request.bitcoinNetworkFee.toBigInt(),
+      dueFrame: request.cosignDueFrame.toNumber(),
+      vaultId: request.vaultId.toNumber(),
+      redemptionPrice: request.redemptionPrice.toBigInt()
+    };
   }
   async submitVaultSignature(args) {
     const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
@@ -2425,7 +2536,7 @@ var BitcoinLocks = class _BitcoinLocks {
         const atHeight = header.number.toNumber();
         this.getVaultCosignSignature(utxoId, atHeight).then((signature) => {
           if (signature) {
-            _optionalChain([unsub, 'optionalCall', _68 => _68()]);
+            _optionalChain([unsub, 'optionalCall', _84 => _84()]);
             clearTimeout(timeout);
             resolve({ signature, blockHeight: atHeight });
           }
@@ -2435,7 +2546,7 @@ var BitcoinLocks = class _BitcoinLocks {
       });
       if (waitForSignatureMillis !== -1) {
         timeout = setTimeout(() => {
-          _optionalChain([unsub, 'optionalCall', _69 => _69()]);
+          _optionalChain([unsub, 'optionalCall', _85 => _85()]);
           reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${utxoId}`));
         }, waitForSignatureMillis);
       }
@@ -2506,7 +2617,8 @@ var BitcoinLocks = class _BitcoinLocks {
       argonKeyring
     );
     const marketPrice = await this.getMarketRate(BigInt(satoshis));
-    const securityFee = vault.calculateBitcoinFee(marketPrice);
+    const isVaultOwner = argonKeyring.address === vault.operatorAccountId;
+    const securityFee = isVaultOwner ? 0n : vault.calculateBitcoinFee(marketPrice);
     const { canAfford, availableBalance, txFee } = await submitter.canAfford({
       tip,
       unavailableBalance: securityFee + (_nullishCoalesce(args.reducedBalanceBy, () => ( 0n))),
@@ -2519,17 +2631,8 @@ var BitcoinLocks = class _BitcoinLocks {
     }
     return { tx, securityFee, txFee };
   }
-  async initializeLock(args) {
-    const { argonKeyring, tip = 0n, txProgressCallback } = args;
+  async getBitcoinLockFromTxResult(txResult) {
     const client = await this.client;
-    const { tx, securityFee } = await this.createInitializeLockTx(args);
-    const submitter = new TxSubmitter(client, tx, argonKeyring);
-    const txResult = await submitter.submit({
-      waitForBlock: true,
-      logResults: true,
-      tip,
-      txProgressCallback
-    });
     const blockHash = await txResult.inBlockPromise;
     const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
     const utxoId = await _asyncNullishCoalesce(await this.getUtxoIdFromEvents(txResult.events), async () => ( 0));
@@ -2540,7 +2643,26 @@ var BitcoinLocks = class _BitcoinLocks {
     if (!lock) {
       throw new Error(`Lock with ID ${utxoId} not found after initialization`);
     }
-    return { lock, createdAtHeight: blockHeight, txResult, securityFee };
+    return { lock, createdAtHeight: blockHeight, txResult };
+  }
+  async initializeLock(args) {
+    const { argonKeyring, tip = 0n, txProgressCallback } = args;
+    const client = await this.client;
+    const { tx, securityFee } = await this.createInitializeLockTx(args);
+    const submitter = new TxSubmitter(client, tx, argonKeyring);
+    const txResult = await submitter.submit({
+      waitForBlock: true,
+      logResults: true,
+      tip,
+      txProgressCallback
+    });
+    const { lock, createdAtHeight } = await this.getBitcoinLockFromTxResult(txResult);
+    return {
+      lock,
+      createdAtHeight,
+      txResult,
+      securityFee
+    };
   }
   async requiredSatoshisForArgonLiquidity(argonAmount) {
     const marketRatePerBitcoin = await this.getMarketRate(SATS_PER_BTC);
@@ -2845,4 +2967,4 @@ async function getClient(host) {
 
 
 exports.WageProtector = WageProtector; exports.setConfig = setConfig; exports.getConfig = getConfig; exports.TxSubmitter = TxSubmitter; exports.TxResult = TxResult; 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-W5SOPU7I.cjs.map
+//# sourceMappingURL=chunk-U6J3AWYW.cjs.map