@argonprotocol/mainchain 1.3.5 → 1.3.6

package/lib/{chunk-GZ2TLGCG.js → chunk-FGSUNAT4.js}

@@ -637,9 +637,13 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
 };
 
 // src/FrameCalculator.ts
-var FrameCalculator = class {
+var FrameCalculator = class _FrameCalculator {
   miningConfig;
   genesisTick;
+  tickMillis;
+  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 = class {
 
 // src/CohortBidder.ts
 var CohortBidder = class {
-  constructor(accountset, cohortStartingFrameId, subaccounts, options) {
+  constructor(accountset, cohortStartingFrameId, subaccounts, options, callbacks) {
     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;
   }
   txFees = 0n;
+  bidsAttempted = 0;
   winningBids = [];
+  myAddresses = /* @__PURE__ */ new Set();
+  currentBids = {
+    bids: [],
+    mostRecentBidTick: 0,
+    atTick: 0,
+    atBlockNumber: 0
+  };
   unsubscribe;
   pendingRequest;
-  retryTimeout;
   isStopped = false;
-  needsRebid = false;
-  lastBidTime = 0;
   millisPerTick;
   minIncrement = 10000n;
   nextCohortSize;
-  lastBidBlockNumber = 0;
-  myAddresses = /* @__PURE__ */ new Set();
+  lastBidTick = 0;
+  evaluateInterval;
   async start() {
     console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
       maxBid: formatArgons(this.options.maxBid),
@@ -1690,7 +1713,7 @@ var CohortBidder = 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 = 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 = 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 = 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) => x[0]?.toNumber()) - 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 = 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 = 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 = 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 = this.options.tipPerTransaction ?? 0n;
       const txResult = await submitter.submit({
@@ -1863,50 +1917,108 @@ var CohortBidder = 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 {
+        this.callbacks?.onBidsSubmitted?.({
+          tick: bidAtTick,
+          blockNumber,
+          microgonsPerSeat,
+          txFeePlusTip: txResult.finalFee ?? 0n,
+          submittedCount: subaccounts.length
+        });
+      } catch (error) {
+        console.error("Error in onBidsSubmitted callback:", error);
       }
       const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
       this.txFees += txResult.finalFee ?? 0n;
-      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 {
+          this.callbacks?.onBidsRejected?.({
+            tick: bidAtTick,
+            blockNumber,
+            microgonsPerSeat,
+            submittedCount: subaccounts.length,
+            rejectedCount: subaccounts.length - successfulBids,
+            bidError
+          });
+        } catch (error) {
+          console.error("Error in onBidsRejected callback:", error);
+        }
+        throw bidError;
+      }
     } catch (err) {
-      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 = existing?.address !== address || existing?.bidMicrogons !== bidMicrogons;
+        }
+        bids.push({
+          address,
+          bidMicrogons,
+          bidAtTick
+        });
+      }
+      if (blockNumber > this.currentBids.atBlockNumber && hasDiffs) {
+        this.currentBids.bids = bids;
+        this.currentBids.mostRecentBidTick = mostRecentBidTick;
+        this.currentBids.atTick = tick;
+        this.currentBids.atBlockNumber = blockNumber;
+        this.winningBids = bids.filter((x) => this.myAddresses.has(x.address));
+        console.log("Now winning bids:", this.winningBids.length);
+        if (this.callbacks?.onBidsUpdated) {
+          this.callbacks.onBidsUpdated({
+            bids: this.winningBids,
+            atBlockNumber: blockNumber,
+            tick: mostRecentBidTick
+          });
+        }
       }
+    } catch (err) {
+      console.error("Error processing updated bids list:", err);
     }
   }
-  async checkCurrentSeats() {
-    const client = await this.client;
-    const bids = await client.query.miningSlot.bidsForNextSlotCohort();
-    await this.checkWinningBids(bids);
+  safeRecordParamsAdjusted(args) {
+    try {
+      this.callbacks?.onBidParamsAdjusted?.(args);
+    } catch (err) {
+      console.error("Error in onBidParamsAdjusted callback:", err);
+    }
   }
 };
 
@@ -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
@@ -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;
@@ -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 + (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 this.getUtxoIdFromEvents(txResult.events) ?? 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 @@ export {
   u64,
   u8
 };
-//# sourceMappingURL=chunk-GZ2TLGCG.js.map
+//# sourceMappingURL=chunk-FGSUNAT4.js.map