@argonprotocol/mainchain 1.3.18 → 1.3.20

package/lib/index.js

@@ -562,8 +562,7 @@ var Vault = class _Vault {
       baseFee,
       bitcoinXpub,
       tip,
-      doNotExceedBalance,
-      txProgressCallback
+      doNotExceedBalance
     } = args;
     let xpubBytes = hexToU8a(bitcoinXpub);
     if (xpubBytes.length !== 78) {
@@ -606,7 +605,6 @@ var Vault = class _Vault {
       ...args,
       useLatestNonce: true
     });
-    const tickDuration = config.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
     async function getVault() {
       await result.waitForFinalizedBlock;
       let vaultId;
@@ -619,11 +617,7 @@ var Vault = class _Vault {
       if (vaultId === void 0) {
         throw new Error("Vault creation failed, no VaultCreated event found");
       }
-      const rawVault = await client.query.vaults.vaultsById(vaultId);
-      if (rawVault.isNone) {
-        throw new Error("Vault creation failed, vault not found");
-      }
-      return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+      return _Vault.get(client, vaultId, config.tickDurationMillis);
     }
     return { getVault, txResult: result };
   }
@@ -645,25 +639,280 @@ function fromFixedNumber(value, decimals = FIXED_U128_DECIMALS) {
 var FIXED_U128_DECIMALS = 18;
 var PERMILL_DECIMALS = 6;
 
-// src/BitcoinLocks.ts
+// src/BitcoinLock.ts
 import { u8aToHex } from "@polkadot/util";
 var SATS_PER_BTC = 100000000n;
-var BitcoinLocks = class {
-  constructor(client) {
-    this.client = client;
+var BitcoinLock = class _BitcoinLock {
+  utxoId;
+  p2wshScriptHashHex;
+  vaultId;
+  peggedPrice;
+  liquidityPromised;
+  ownerAccount;
+  satoshis;
+  vaultPubkey;
+  securityFees;
+  vaultClaimPubkey;
+  ownerPubkey;
+  vaultXpubSources;
+  vaultClaimHeight;
+  openClaimHeight;
+  createdAtHeight;
+  isVerified;
+  isRejectedNeedsRelease;
+  fundHoldExtensionsByBitcoinExpirationHeight;
+  constructor(data) {
+    this.utxoId = data.utxoId;
+    this.p2wshScriptHashHex = data.p2wshScriptHashHex;
+    this.vaultId = data.vaultId;
+    this.peggedPrice = data.peggedPrice;
+    this.liquidityPromised = data.liquidityPromised;
+    this.ownerAccount = data.ownerAccount;
+    this.satoshis = data.satoshis;
+    this.vaultPubkey = data.vaultPubkey;
+    this.securityFees = data.securityFees;
+    this.vaultClaimPubkey = data.vaultClaimPubkey;
+    this.ownerPubkey = data.ownerPubkey;
+    this.vaultXpubSources = data.vaultXpubSources;
+    this.vaultClaimHeight = data.vaultClaimHeight;
+    this.openClaimHeight = data.openClaimHeight;
+    this.createdAtHeight = data.createdAtHeight;
+    this.isVerified = data.isVerified;
+    this.isRejectedNeedsRelease = data.isRejectedNeedsRelease;
+    this.fundHoldExtensionsByBitcoinExpirationHeight = data.fundHoldExtensionsByBitcoinExpirationHeight;
+  }
+  /**
+   * Gets the UTXO reference by ID.
+   * @param client - client at the block height to query the UTXO reference at a specific point in time.
+   * @return An object containing the transaction ID and output index, or undefined if not found.
+   * @return.txid - The Bitcoin transaction ID of the UTXO.
+   * @return.vout - The output index of the UTXO in the transaction.
+   * @return.bitcoinTxid - The Bitcoin transaction ID of the UTXO formatted in little endian
+   */
+  async getUtxoRef(client) {
+    const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(this.utxoId);
+    if (!refRaw) {
+      return;
+    }
+    const ref = refRaw.unwrap();
+    const txid = u8aToHex(ref.txid);
+    const bitcoinTxid = u8aToHex(ref.txid.reverse());
+    const vout = ref.outputIndex.toNumber();
+    return { txid, vout, bitcoinTxid };
+  }
+  async findPendingMints(client) {
+    const pendingMint = await client.query.mint.pendingMintUtxos();
+    const mintsPending = [];
+    for (const [utxoIdRaw, _accountId, mintAmountRaw] of pendingMint) {
+      if (utxoIdRaw.toNumber() === this.utxoId) {
+        mintsPending.push(mintAmountRaw.toBigInt());
+      }
+    }
+    return mintsPending;
+  }
+  async getRatchetPrice(client, priceIndex, vault) {
+    const { createdAtHeight, vaultClaimHeight, peggedPrice, satoshis } = this;
+    const marketRate = await _BitcoinLock.getMarketRate(priceIndex, BigInt(satoshis));
+    let ratchetingFee = vault.terms.bitcoinBaseFee;
+    let burnAmount = 0n;
+    if (marketRate > peggedPrice) {
+      const lockFee = vault.calculateBitcoinFee(marketRate);
+      const currentBitcoinHeight = await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
+      const blockLength = vaultClaimHeight - createdAtHeight;
+      const elapsed = (currentBitcoinHeight - createdAtHeight) / blockLength;
+      const remainingDuration = 1 - elapsed;
+      ratchetingFee = BigInt(remainingDuration * Number(lockFee));
+    } else {
+      burnAmount = await this.releasePrice(priceIndex);
+    }
+    return {
+      ratchetingFee,
+      burnAmount,
+      marketRate
+    };
+  }
+  async ratchet(args) {
+    const { priceIndex, argonKeyring, tip = 0n, vault, client } = args;
+    const ratchetPrice = await this.getRatchetPrice(client, priceIndex, vault);
+    const txSubmitter = new TxSubmitter(
+      client,
+      client.tx.bitcoinLocks.ratchet(this.utxoId),
+      argonKeyring
+    );
+    const canAfford = await txSubmitter.canAfford({
+      tip,
+      unavailableBalance: BigInt(ratchetPrice.burnAmount + ratchetPrice.ratchetingFee)
+    });
+    if (!canAfford.canAfford) {
+      throw new Error(
+        `Insufficient funds to ratchet lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(
+          ratchetPrice.burnAmount + ratchetPrice.ratchetingFee
+        )}`
+      );
+    }
+    const txResult = await txSubmitter.submit(args);
+    const getRatchetResult = async () => {
+      const blockHash = await txResult.waitForFinalizedBlock;
+      const ratchetEvent = txResult.events.find(
+        (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
+      );
+      if (!ratchetEvent) {
+        throw new Error(`Ratchet event not found in transaction events`);
+      }
+      const api = await client.at(blockHash);
+      const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
+      const {
+        amountBurned,
+        liquidityPromised: liquidityPromisedRaw,
+        newPeggedPrice,
+        originalPeggedPrice,
+        securityFee
+      } = ratchetEvent.data;
+      const liquidityPromised = liquidityPromisedRaw.toBigInt();
+      let mintAmount = liquidityPromised;
+      if (liquidityPromised > originalPeggedPrice.toBigInt()) {
+        mintAmount -= originalPeggedPrice.toBigInt();
+      }
+      return {
+        txFee: txResult.finalFee ?? 0n,
+        blockHeight: txResult.blockNumber,
+        bitcoinBlockHeight,
+        pendingMint: mintAmount,
+        liquidityPromised,
+        newPeggedPrice: newPeggedPrice.toBigInt(),
+        burned: amountBurned.toBigInt(),
+        securityFee: securityFee.toBigInt()
+      };
+    };
+    return {
+      txResult,
+      getRatchetResult
+    };
+  }
+  async releasePrice(priceIndex) {
+    return await _BitcoinLock.getRedemptionRate(priceIndex, this);
   }
-  async getUtxoIdFromEvents(events) {
+  async requestRelease(args) {
+    const {
+      priceIndex,
+      releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
+      argonKeyring,
+      tip = 0n,
+      client
+    } = args;
+    if (!toScriptPubkey.startsWith("0x")) {
+      throw new Error("toScriptPubkey must be a hex string starting with 0x");
+    }
+    const submitter = new TxSubmitter(
+      client,
+      client.tx.bitcoinLocks.requestRelease(this.utxoId, toScriptPubkey, bitcoinNetworkFee),
+      argonKeyring
+    );
+    const redemptionPrice = await _BitcoinLock.getRedemptionRate(priceIndex, this);
+    const canAfford = await submitter.canAfford({
+      tip,
+      unavailableBalance: BigInt(redemptionPrice)
+    });
+    if (!canAfford.canAfford) {
+      throw new Error(
+        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice + canAfford.txFee + tip)}`
+      );
+    }
+    return submitter.submit({
+      logResults: true,
+      ...args
+    });
+  }
+  async getReleaseRequest(client) {
+    const requestMaybe = await client.query.bitcoinLocks.lockReleaseRequestsByUtxoId(this.utxoId);
+    if (!requestMaybe.isSome) {
+      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()
+    };
+  }
+  /**
+   * Finds the cosign signature for a vault lock by UTXO ID. Optionally waits for the signature
+   * @param client - The Argon client with rpc access
+   * @param finalizedStateOnly - If true, only checks finalized state
+   * @param waitForSignatureMillis - Optional timeout in milliseconds to wait for the signature. If -1, waits indefinitely.
+   */
+  async findVaultCosignSignature(client, finalizedStateOnly = false, waitForSignatureMillis) {
+    let queryClient = client;
+    if (finalizedStateOnly) {
+      const finalizedHead = await client.rpc.chain.getFinalizedHead();
+      queryClient = await client.at(finalizedHead);
+    }
+    const releaseHeight = await queryClient.query.bitcoinLocks.lockReleaseCosignHeightById(
+      this.utxoId
+    );
+    if (releaseHeight.isSome) {
+      const releaseHeightValue = releaseHeight.unwrap().toNumber();
+      const signature = await this.getVaultCosignSignature(client, releaseHeightValue);
+      if (signature) {
+        return { blockHeight: releaseHeightValue, signature };
+      }
+    }
+    if (!waitForSignatureMillis) {
+      return void 0;
+    }
+    return await new Promise(async (resolve, reject) => {
+      let timeout;
+      const unsub = await client.rpc.chain.subscribeNewHeads((header) => {
+        const atHeight = header.number.toNumber();
+        this.getVaultCosignSignature(client, atHeight).then((signature) => {
+          if (signature) {
+            unsub?.();
+            clearTimeout(timeout);
+            resolve({ signature, blockHeight: atHeight });
+          }
+        }).catch((err) => {
+          console.error(`Error checking for cosign signature at height ${atHeight}:`, err);
+        });
+      });
+      if (waitForSignatureMillis !== -1) {
+        timeout = setTimeout(() => {
+          unsub?.();
+          reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${this.utxoId}`));
+        }, waitForSignatureMillis);
+      }
+    });
+  }
+  async getVaultCosignSignature(client, atHeight) {
+    const blockHash = await _BitcoinLock.blockHashAtHeight(client, atHeight);
+    if (!blockHash) {
+      console.warn(`Block hash not found for height ${atHeight}`);
+      return void 0;
+    }
+    const blockEvents = await client.at(blockHash).then((api) => api.query.system.events());
+    for (const event of blockEvents) {
+      if (client.events.bitcoinLocks.BitcoinUtxoCosigned.is(event.event)) {
+        const { utxoId: id, signature } = event.event.data;
+        if (id.toNumber() === this.utxoId) {
+          return new Uint8Array(signature);
+        }
+      }
+    }
+    return void 0;
+  }
+  static async getUtxoIdFromEvents(client, events) {
     for (const event of events) {
-      if (this.client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
+      if (client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
         return event.data.utxoId.toNumber();
       }
     }
     return void 0;
   }
-  async getMarketRate(priceIndex, satoshis) {
+  static async getMarketRate(priceIndex, satoshis) {
     return priceIndex.getBtcMicrogonPrice(satoshis);
   }
-  async getRedemptionRate(priceIndex, details) {
+  static async getRedemptionRate(priceIndex, details) {
     const { satoshis, peggedPrice } = details;
     const satsPerArgon = Number(SATS_PER_BTC) / MICROGONS_PER_ARGON;
     let price = Number(priceIndex.btcUsdPrice);
@@ -684,28 +933,7 @@ var BitcoinLocks = class {
     }
     return BigInt(Math.floor(price * multiplier));
   }
-  async getMarketRateApi(satoshis) {
-    const client = this.client;
-    const sats = client.createType("U64", satoshis.toString());
-    const marketRate = await client.rpc.state.call("BitcoinApis_market_rate", sats.toHex(true));
-    const rate = client.createType("Option<U128>", marketRate);
-    if (!rate.isSome) {
-      throw new Error("Market rate not available");
-    }
-    return rate.value.toBigInt();
-  }
-  async getRedemptionRateApi(satoshis) {
-    const client = this.client;
-    const sats = client.createType("U64", satoshis.toString());
-    const marketRate = await client.rpc.state.call("BitcoinApis_redemption_rate", sats.toHex(true));
-    const rate = client.createType("Option<U128>", marketRate);
-    if (!rate.isSome) {
-      throw new Error("Redemption rate not available");
-    }
-    return rate.value.toBigInt();
-  }
-  async getConfig() {
-    const client = this.client;
+  static async getConfig(client) {
     const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
     return {
       lockReleaseCosignDeadlineFrames: client.consts.bitcoinLocks.lockReleaseCosignDeadlineFrames.toNumber(),
@@ -714,48 +942,11 @@ var BitcoinLocks = class {
       bitcoinNetwork
     };
   }
-  async getBitcoinConfirmedBlockHeight() {
-    return await this.client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.value?.blockHeight.toNumber() ?? 0);
-  }
-  /**
-   * Gets the UTXO reference by ID.
-   * @param utxoId - The UTXO ID to look up.
-   * @param clientAtHeight - Optional client at the block height to query the UTXO reference at a specific point in time.
-   * @return An object containing the transaction ID and output index, or undefined if not found.
-   * @return.txid - The Bitcoin transaction ID of the UTXO.
-   * @return.vout - The output index of the UTXO in the transaction.
-   * @return.bitcoinTxid - The Bitcoin transaction ID of the UTXO formatted in little endian
-   */
-  async getUtxoRef(utxoId, clientAtHeight) {
-    const client = clientAtHeight ?? this.client;
-    const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
-    if (!refRaw) {
-      return;
-    }
-    const ref = refRaw.unwrap();
-    const txid = u8aToHex(ref.txid);
-    const bitcoinTxid = u8aToHex(ref.txid.reverse());
-    const vout = ref.outputIndex.toNumber();
-    return { txid, vout, bitcoinTxid };
-  }
-  async getReleaseRequest(utxoId, clientAtHeight) {
-    const client = clientAtHeight ?? this.client;
-    const requestMaybe = await client.query.bitcoinLocks.lockReleaseRequestsByUtxoId(utxoId);
-    if (!requestMaybe.isSome) {
-      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()
-    };
+  static async getBitcoinConfirmedBlockHeight(client) {
+    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.value?.blockHeight.toNumber() ?? 0);
   }
-  async submitVaultSignature(args) {
-    const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
-    const client = this.client;
+  static async submitVaultSignature(args) {
+    const { utxoId, vaultSignature, argonKeyring, client } = args;
     if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
       throw new Error(
         `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
@@ -766,8 +957,8 @@ var BitcoinLocks = class {
     const submitter = new TxSubmitter(client, tx, argonKeyring);
     return await submitter.submit(args);
   }
-  async getBitcoinLock(utxoId) {
-    const utxoRaw = await this.client.query.bitcoinLocks.locksByUtxoId(utxoId);
+  static async get(client, utxoId) {
+    const utxoRaw = await client.query.bitcoinLocks.locksByUtxoId(utxoId);
     if (!utxoRaw.isSome) {
       return;
     }
@@ -798,7 +989,7 @@ var BitcoinLocks = class {
     const fundHoldExtensionsByBitcoinExpirationHeight = Object.fromEntries(
       [...utxo.fundHoldExtensions.entries()].map(([x, y]) => [x.toNumber(), y.toBigInt()])
     );
-    return {
+    return new _BitcoinLock({
       utxoId,
       p2wshScriptHashHex,
       vaultId,
@@ -817,50 +1008,9 @@ var BitcoinLocks = class {
       isVerified,
       isRejectedNeedsRelease,
       fundHoldExtensionsByBitcoinExpirationHeight
-    };
-  }
-  /**
-   * Finds the cosign signature for a vault lock by UTXO ID. Optionally waits for the signature
-   * @param utxoId - The UTXO ID of the bitcoin lock
-   * @param waitForSignatureMillis - Optional timeout in milliseconds to wait for the signature. If -1, waits indefinitely.
-   */
-  async findVaultCosignSignature(utxoId, waitForSignatureMillis) {
-    const client = this.client;
-    const releaseHeight = await client.query.bitcoinLocks.lockReleaseCosignHeightById(utxoId);
-    if (releaseHeight.isSome) {
-      const releaseHeightValue = releaseHeight.unwrap().toNumber();
-      const signature = await this.getVaultCosignSignature(utxoId, releaseHeightValue);
-      if (signature) {
-        return { blockHeight: releaseHeightValue, signature };
-      }
-    }
-    if (!waitForSignatureMillis) {
-      return void 0;
-    }
-    return await new Promise(async (resolve, reject) => {
-      let timeout;
-      const unsub = await client.rpc.chain.subscribeNewHeads((header) => {
-        const atHeight = header.number.toNumber();
-        this.getVaultCosignSignature(utxoId, atHeight).then((signature) => {
-          if (signature) {
-            unsub?.();
-            clearTimeout(timeout);
-            resolve({ signature, blockHeight: atHeight });
-          }
-        }).catch((err) => {
-          console.error(`Error checking for cosign signature at height ${atHeight}:`, err);
-        });
-      });
-      if (waitForSignatureMillis !== -1) {
-        timeout = setTimeout(() => {
-          unsub?.();
-          reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${utxoId}`));
-        }, waitForSignatureMillis);
-      }
     });
   }
-  async blockHashAtHeight(atHeight) {
-    const client = this.client;
+  static async blockHashAtHeight(client, atHeight) {
     for (let i = 0; i < 10; i++) {
       const currentHeight = await client.query.system.number().then((x) => x.toNumber());
       if (atHeight > currentHeight) {
@@ -880,37 +1030,16 @@ var BitcoinLocks = class {
     }
     return void 0;
   }
-  async getVaultCosignSignature(utxoId, atHeight) {
-    const client = this.client;
-    const blockHash = await this.blockHashAtHeight(atHeight);
-    if (!blockHash) {
-      console.warn(`Block hash not found for height ${atHeight}`);
-      return void 0;
-    }
-    const blockEvents = await client.at(blockHash).then((api) => api.query.system.events());
-    for (const event of blockEvents) {
-      if (client.events.bitcoinLocks.BitcoinUtxoCosigned.is(event.event)) {
-        const { utxoId: id, signature } = event.event.data;
-        if (id.toNumber() === utxoId) {
-          return new Uint8Array(signature);
-        }
-      }
-    }
-    return void 0;
-  }
-  async findPendingMints(utxoId) {
-    const pendingMint = await this.client.query.mint.pendingMintUtxos();
-    const mintsPending = [];
-    for (const [utxoIdRaw, _accountId, mintAmountRaw] of pendingMint) {
-      if (utxoIdRaw.toNumber() === utxoId) {
-        mintsPending.push(mintAmountRaw.toBigInt());
-      }
-    }
-    return mintsPending;
-  }
-  async createInitializeLockTx(args) {
-    const { vault, priceIndex, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
-    const client = this.client;
+  static async createInitializeTx(args) {
+    const {
+      vault,
+      priceIndex,
+      argonKeyring,
+      satoshis,
+      tip = 0n,
+      ownerBitcoinPubkey,
+      client
+    } = args;
     if (ownerBitcoinPubkey.length !== 33) {
       throw new Error(
         `Invalid Bitcoin key length: ${ownerBitcoinPubkey.length}. Must be a compressed pukey (33 bytes).`
@@ -932,23 +1061,9 @@ var BitcoinLocks = class {
     });
     return { tx, securityFee, txFee, canAfford, availableBalance, txFeePlusTip: txFee + tip };
   }
-  async getBitcoinLockFromTxResult(txResult) {
-    await txResult.waitForFinalizedBlock;
-    const blockHeight = txResult.blockNumber;
-    const utxoId = await this.getUtxoIdFromEvents(txResult.events) ?? 0;
-    if (utxoId === 0) {
-      throw new Error("Bitcoin lock creation failed, no UTXO ID found in transaction events");
-    }
-    const lock = await this.getBitcoinLock(utxoId);
-    if (!lock) {
-      throw new Error(`Lock with ID ${utxoId} not found after initialization`);
-    }
-    return { lock, createdAtHeight: blockHeight, txResult };
-  }
-  async initializeLock(args) {
-    const { argonKeyring } = args;
-    const client = this.client;
-    const { tx, securityFee, canAfford, txFeePlusTip } = await this.createInitializeLockTx(args);
+  static async initialize(args) {
+    const { argonKeyring, client } = args;
+    const { tx, securityFee, canAfford, txFeePlusTip } = await this.createInitializeTx(args);
     if (!canAfford) {
       throw new Error(
         `Insufficient funds to initialize bitcoin lock. Required security fee: ${formatArgons(securityFee)}, Tx fee plus tip: ${formatArgons(txFeePlusTip)}`
@@ -957,130 +1072,27 @@ var BitcoinLocks = class {
     const submitter = new TxSubmitter(client, tx, argonKeyring);
     const txResult = await submitter.submit({ logResults: true, ...args });
     return {
-      getLock: () => this.getBitcoinLockFromTxResult(txResult),
+      getLock: () => this.getBitcoinLockFromTxResult(client, txResult),
       txResult,
       securityFee
     };
   }
-  async requiredSatoshisForArgonLiquidity(priceIndex, argonAmount) {
-    const marketRatePerBitcoin = priceIndex.getBtcMicrogonPrice(SATS_PER_BTC);
-    return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
-  }
-  async requestRelease(args) {
-    const client = this.client;
-    const {
-      lock,
-      priceIndex,
-      releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
-      argonKeyring,
-      tip = 0n
-    } = args;
-    if (!toScriptPubkey.startsWith("0x")) {
-      throw new Error("toScriptPubkey must be a hex string starting with 0x");
-    }
-    const submitter = new TxSubmitter(
-      client,
-      client.tx.bitcoinLocks.requestRelease(lock.utxoId, toScriptPubkey, bitcoinNetworkFee),
-      argonKeyring
-    );
-    const redemptionPrice = await this.getRedemptionRate(priceIndex, lock);
-    const canAfford = await submitter.canAfford({
-      tip,
-      unavailableBalance: BigInt(redemptionPrice)
-    });
-    if (!canAfford.canAfford) {
-      throw new Error(
-        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice + canAfford.txFee + tip)}`
-      );
+  static async getBitcoinLockFromTxResult(client, txResult) {
+    await txResult.waitForFinalizedBlock;
+    const blockHeight = txResult.blockNumber;
+    const utxoId = await this.getUtxoIdFromEvents(client, txResult.events) ?? 0;
+    if (utxoId === 0) {
+      throw new Error("Bitcoin lock creation failed, no UTXO ID found in transaction events");
     }
-    return submitter.submit({
-      logResults: true,
-      ...args
-    });
-  }
-  async releasePrice(priceIndex, lock) {
-    return await this.getRedemptionRate(priceIndex, lock);
-  }
-  async getRatchetPrice(lock, priceIndex, vault) {
-    const { createdAtHeight, vaultClaimHeight, peggedPrice, satoshis } = lock;
-    const client = this.client;
-    const marketRate = await this.getMarketRate(priceIndex, BigInt(satoshis));
-    let ratchetingFee = vault.terms.bitcoinBaseFee;
-    let burnAmount = 0n;
-    if (marketRate > peggedPrice) {
-      const lockFee = vault.calculateBitcoinFee(marketRate);
-      const currentBitcoinHeight = await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
-      const blockLength = vaultClaimHeight - createdAtHeight;
-      const elapsed = (currentBitcoinHeight - createdAtHeight) / blockLength;
-      const remainingDuration = 1 - elapsed;
-      ratchetingFee = BigInt(remainingDuration * Number(lockFee));
-    } else {
-      burnAmount = await this.releasePrice(priceIndex, lock);
+    const lock = await this.get(client, utxoId);
+    if (!lock) {
+      throw new Error(`Lock with ID ${utxoId} not found after initialization`);
     }
-    return {
-      ratchetingFee,
-      burnAmount,
-      marketRate
-    };
+    return { lock, createdAtHeight: blockHeight, txResult };
   }
-  async ratchet(args) {
-    const { lock, priceIndex, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
-    const client = this.client;
-    const ratchetPrice = await this.getRatchetPrice(lock, priceIndex, vault);
-    const txSubmitter = new TxSubmitter(
-      client,
-      client.tx.bitcoinLocks.ratchet(lock.utxoId),
-      argonKeyring
-    );
-    const canAfford = await txSubmitter.canAfford({
-      tip,
-      unavailableBalance: BigInt(ratchetPrice.burnAmount + ratchetPrice.ratchetingFee)
-    });
-    if (!canAfford.canAfford) {
-      throw new Error(
-        `Insufficient funds to ratchet lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(
-          ratchetPrice.burnAmount + ratchetPrice.ratchetingFee
-        )}`
-      );
-    }
-    const txResult = await txSubmitter.submit(args);
-    const getRatchetResult = async () => {
-      const blockHash = await txResult.waitForFinalizedBlock;
-      const ratchetEvent = txResult.events.find(
-        (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
-      );
-      if (!ratchetEvent) {
-        throw new Error(`Ratchet event not found in transaction events`);
-      }
-      const api = await client.at(blockHash);
-      const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
-      const {
-        amountBurned,
-        liquidityPromised: liquidityPromisedRaw,
-        newPeggedPrice,
-        originalPeggedPrice,
-        securityFee
-      } = ratchetEvent.data;
-      const liquidityPromised = liquidityPromisedRaw.toBigInt();
-      let mintAmount = liquidityPromised;
-      if (liquidityPromised > originalPeggedPrice.toBigInt()) {
-        mintAmount -= originalPeggedPrice.toBigInt();
-      }
-      return {
-        txFee: txResult.finalFee ?? 0n,
-        blockHeight: txResult.blockNumber,
-        bitcoinBlockHeight,
-        pendingMint: mintAmount,
-        liquidityPromised,
-        newPeggedPrice: newPeggedPrice.toBigInt(),
-        burned: amountBurned.toBigInt(),
-        securityFee: securityFee.toBigInt()
-      };
-    };
-    return {
-      txResult,
-      getRatchetResult
-    };
+  static async requiredSatoshisForArgonLiquidity(priceIndex, argonAmount) {
+    const marketRatePerBitcoin = priceIndex.getBtcMicrogonPrice(SATS_PER_BTC);
+    return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
   }
 };
 
@@ -1183,7 +1195,7 @@ async function getClient(host, options) {
 }
 export {
   BTreeMap,
-  BitcoinLocks,
+  BitcoinLock,
   Bool,
   Bytes,
   Compact,