@argonprotocol/mainchain 1.2.0 → 1.3.0

package/lib/{chunk-CHGCEO2U.cjs → chunk-SHAEHPI5.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 _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(); } } 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 _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
 require('@polkadot/api-base/types/consts');
 
 // src/interfaces/augment-api-errors.ts
@@ -24,10 +24,6 @@ require('@polkadot/types/types/registry');
 
 // src/index.ts
 var _api = require('@polkadot/api');
-
-
-
-
 var _utilcrypto = require('@polkadot/util-crypto');
 
 // src/WageProtector.ts
@@ -60,7 +56,7 @@ var WageProtector = class _WageProtector {
         new _WageProtector({
           argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
           argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
-          finalizedBlock: finalizedBlock.toU8a(),
+          finalizedBlock: Buffer.from(finalizedBlock),
           tick: cpi.value.tick.toBigInt()
         })
       );
@@ -137,9 +133,7 @@ var TxSubmitter = class {
     }
     args.unshift(txString.join("->"));
     if (options.useLatestNonce && !options.nonce) {
-      options.nonce = await this.client.rpc.system.accountNextIndex(
-        this.pair.address
-      );
+      options.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));
@@ -197,7 +191,7 @@ var TxResult = (_class = class {
     }
     const { events, status, dispatchError, isFinalized } = result;
     if (status.isInBlock) {
-      this.includedInBlock = status.asInBlock.toU8a();
+      this.includedInBlock = Buffer.from(status.asInBlock);
       let encounteredError = dispatchError;
       let batchErrorIndex;
       for (const event of events) {
@@ -207,23 +201,17 @@ var TxResult = (_class = class {
           this.batchInterruptedIndex = batchErrorIndex;
           encounteredError = event.event.data[1];
         }
-        if (this.client.events.transactionPayment.TransactionFeePaid.is(
-          event.event
-        )) {
+        if (this.client.events.transactionPayment.TransactionFeePaid.is(event.event)) {
           const [_who, actualFee, tip] = event.event.data;
           this.finalFee = actualFee.toBigInt();
           this.finalFeeTip = tip.toBigInt();
         }
       }
       if (encounteredError) {
-        const error = dispatchErrorToExtrinsicError(
-          this.client,
-          encounteredError,
-          batchErrorIndex
-        );
+        const error = dispatchErrorToExtrinsicError(this.client, encounteredError, batchErrorIndex);
         this.reject(error);
       } else {
-        this.inBlockResolve(status.asInBlock.toU8a());
+        this.inBlockResolve(Buffer.from(status.asInBlock));
       }
     }
     if (isFinalized) {
@@ -255,9 +243,7 @@ function formatPercent(x) {
 }
 function filterUndefined(obj) {
   return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([_, value]) => value !== void 0 && value !== null
-    )
+    Object.entries(obj).filter(([_, value]) => value !== void 0 && value !== null)
   );
 }
 async function gettersToObject(obj) {
@@ -285,6 +271,14 @@ 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 convertNumberToFixedU128(value) {
+  return toFixedNumber(value, 18);
+}
 function convertFixedU128ToBigNumber(fixedU128) {
   const decimalFactor = new (0, BN.default)(10).pow(new (0, BN.default)(18));
   const rawValue = new (0, BN.default)(fixedU128.toString());
@@ -295,6 +289,9 @@ function convertPermillToBigNumber(permill) {
   const rawValue = new (0, BN.default)(permill.toString());
   return rawValue.div(decimalFactor);
 }
+function convertNumberToPermill(value) {
+  return toFixedNumber(value, 6);
+}
 function eventDataToJson(event) {
   const obj = {};
   event.data.forEach((data, index) => {
@@ -330,11 +327,7 @@ function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
   if (error.isModule) {
     const decoded = client.registry.findMetaError(error.asModule);
     const { docs, name, section } = decoded;
-    return new ExtrinsicError2(
-      `${section}.${name}`,
-      docs.join(" "),
-      batchInterruptedIndex
-    );
+    return new ExtrinsicError2(`${section}.${name}`, docs.join(" "), batchInterruptedIndex);
   }
   return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
 }
@@ -350,11 +343,7 @@ function checkForExtrinsicSuccess(events, client) {
           const decoded = client.registry.findMetaError(dispatchError.asModule);
           errorInfo = `${decoded.section}.${decoded.name}`;
         }
-        reject(
-          new Error(
-            `${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`
-          )
-        );
+        reject(new Error(`${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`));
       }
     }
   });
@@ -363,15 +352,26 @@ var JsonExt = class {
   static stringify(obj, space) {
     return JSON.stringify(
       obj,
-      (_, v) => typeof v === "bigint" ? `${v}n` : v,
+      (_, v) => {
+        if (typeof v === "bigint") {
+          return `${v}n`;
+        }
+        if (Buffer.isBuffer(v)) {
+          return Buffer.from(v).toJSON();
+        }
+        return v;
+      },
       space
     );
   }
   static parse(str) {
     return JSON.parse(str, (_, v) => {
-      if (typeof v === "string" && v.endsWith("n")) {
+      if (typeof v === "string" && v.match(/^\d+n$/)) {
         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 v;
     });
   }
@@ -502,9 +502,7 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
           logEvent = true;
         } else if (client.events.liquidityPools.NextBidPoolCapitalLocked.is(event)) {
           const { totalActivatedCapital } = event.data;
-          data.totalActivatedCapital = formatArgons(
-            totalActivatedCapital.toBigInt()
-          );
+          data.totalActivatedCapital = formatArgons(totalActivatedCapital.toBigInt());
           logEvent = true;
         }
       } else if (event.section === "bitcoinLocks") {
@@ -543,10 +541,7 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
         logEvent = true;
         if (client.events.bitcoinUtxos.UtxoVerified.is(event)) {
           const { utxoId } = event.data;
-          const details = await this.getBitcoinLockDetails(
-            utxoId.toNumber(),
-            blockHash
-          );
+          const details = await this.getBitcoinLockDetails(utxoId.toNumber(), blockHash);
           this.events.emit("bitcoin-verified", header, {
             utxoId: utxoId.toNumber(),
             vaultId: details.vaultId,
@@ -582,8 +577,7 @@ BLOCK #${header.number}, ${header.hash.toHuman()}`);
       }
       this.events.emit("event", header, event);
     }
-    if (reloadVaults.size)
-      this.events.emit("vaults-updated", header, reloadVaults);
+    if (reloadVaults.size) this.events.emit("vaults-updated", header, reloadVaults);
     const tick = getTickFromHeader(client, header);
     const author = getAuthorFromHeader(client, header);
     this.events.emit(
@@ -674,10 +668,7 @@ var AccountMiners = (_class5 = class _AccountMiners {
     if (author) {
       const voteAuthor = this.trackedAccountsByAddress[author];
       if (voteAuthor && this.options.shouldLog) {
-        console.log(
-          "> Our vote author",
-          this.accountset.accountRegistry.getName(author)
-        );
+        console.log("> Our vote author", this.accountset.accountRegistry.getName(author));
       }
     } else {
       console.warn("> No vote author found");
@@ -720,9 +711,7 @@ var AccountMiners = (_class5 = class _AccountMiners {
         const { perMiner } = event.data;
         const amountPerMiner = perMiner.toBigInt();
         if (amountPerMiner > 0n) {
-          for (const [address, info] of Object.entries(
-            this.trackedAccountsByAddress
-          )) {
+          for (const [address, info] of Object.entries(this.trackedAccountsByAddress)) {
             const { startingFrameId } = info;
             dataByCohort[startingFrameId] ??= {
               argonsMinted: 0n,
@@ -746,9 +735,7 @@ var AccountMiners = (_class5 = class _AccountMiners {
     return dataByCohort;
   }
   newCohortMiners(frameId, addresses) {
-    for (const [address, info] of Object.entries(
-      this.trackedAccountsByAddress
-    )) {
+    for (const [address, info] of Object.entries(this.trackedAccountsByAddress)) {
       if (info.startingFrameId === frameId - 10) {
         delete this.trackedAccountsByAddress[address];
       }
@@ -801,25 +788,17 @@ var Accountset = (_class6 = class {
     this.accountRegistry = _nullishCoalesce(options.accountRegistry, () => ( AccountRegistry.factory(options.name)));
     this.client = options.client;
     const defaultRange = _nullishCoalesce(options.subaccountRange, () => ( getDefaultSubaccountRange()));
-    this.accountRegistry.register(
-      this.seedAddress,
-      `${this.accountRegistry.me}//seed`
-    );
+    this.accountRegistry.register(this.seedAddress, `${this.accountRegistry.me}//seed`);
     for (const i of defaultRange) {
       const pair = this.txSubmitterPair.derive(`//${i}`);
       this.subAccountsByAddress[pair.address] = { pair, index: i };
-      this.accountRegistry.register(
-        pair.address,
-        `${this.accountRegistry.me}//${i}`
-      );
+      this.accountRegistry.register(pair.address, `${this.accountRegistry.me}//${i}`);
     }
   }
   async submitterBalance(blockHash) {
     const client = await this.client;
     const api = blockHash ? await client.at(blockHash) : client;
-    const accountData = await api.query.system.account(
-      this.txSubmitterPair.address
-    );
+    const accountData = await api.query.system.account(this.txSubmitterPair.address);
     return accountData.data.free.toBigInt();
   }
   async balance(blockHash) {
@@ -978,9 +957,7 @@ var Accountset = (_class6 = class {
               const error = dispatchErrorToString(client, cb.dispatchError);
               results.push({
                 index,
-                failedError: new Error(
-                  `Error consolidating //${index}: ${error}`
-                )
+                failedError: new Error(`Error consolidating //${index}: ${error}`)
               });
               resolve();
             }
@@ -1003,17 +980,11 @@ 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', _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)))
       }
     ];
-    for (const [address, { index }] of Object.entries(
-      this.subAccountsByAddress
-    )) {
+    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 bid = bids.find((x) => x.address === address);
@@ -1039,11 +1010,7 @@ var Accountset = (_class6 = class {
     const keys = this.keys();
     for (const [name, key] of Object.entries(keys)) {
       console.log("Registering key", name, key.publicKey);
-      const result = await client.rpc.author.insertKey(
-        name,
-        key.privateKey,
-        key.publicKey
-      );
+      const result = await client.rpc.author.insertKey(name, key.privateKey, key.publicKey);
       const saved = await client.rpc.author.hasKey(key.publicKey, name);
       if (!saved) {
         console.error("Failed to register key", name, key.publicKey);
@@ -1060,9 +1027,7 @@ var Accountset = (_class6 = class {
     }
     const seedMnemonic = _nullishCoalesce(this.sessionKeyMnemonic, () => ( process2.env.KEYS_MNEMONIC));
     if (!seedMnemonic) {
-      throw new Error(
-        "KEYS_MNEMONIC environment variable not set. Cannot derive keys."
-      );
+      throw new Error("KEYS_MNEMONIC environment variable not set. Cannot derive keys.");
     }
     const blockSealKey = `${seedMnemonic}//block-seal//${version}`;
     const granKey = `${seedMnemonic}//grandpa//${version}`;
@@ -1255,31 +1220,25 @@ var MiningBids = (_class7 = class {
   async watch(accountNames, blockHash, printFn) {
     const client = await this.client;
     const api = blockHash ? await client.at(blockHash) : client;
-    const unsubscribe = await api.query.miningSlot.bidsForNextSlotCohort(
-      async (next) => {
-        this.nextCohort = await Promise.all(
-          next.map((x) => this.toBid(accountNames, x))
-        );
-        if (!this.shouldLog) return;
-        console.clear();
-        const block = await client.query.system.number();
-        if (!printFn) {
-          console.log("At block", block.toNumber());
-          this.print();
-        } else {
-          printFn(block.toNumber());
-        }
+    const unsubscribe = await api.query.miningSlot.bidsForNextSlotCohort(async (next) => {
+      this.nextCohort = await Promise.all(next.map((x) => this.toBid(accountNames, x)));
+      if (!this.shouldLog) return;
+      console.clear();
+      const block = await client.query.system.number();
+      if (!printFn) {
+        console.log("At block", block.toNumber());
+        this.print();
+      } else {
+        printFn(block.toNumber());
       }
-    );
+    });
     return { unsubscribe };
   }
   async loadAt(accountNames, blockHash) {
     const client = await this.client;
     const api = blockHash ? await client.at(blockHash) : client;
     const nextCohort = await api.query.miningSlot.bidsForNextSlotCohort();
-    this.nextCohort = await Promise.all(
-      nextCohort.map((x) => this.toBid(accountNames, x))
-    );
+    this.nextCohort = await Promise.all(nextCohort.map((x) => this.toBid(accountNames, x)));
   }
   async toBid(accountNames, bid) {
     return {
@@ -1305,25 +1264,13 @@ 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 {
-  
-  
-  
-  
-  __init12() {this.argonsScheduledForRelease = /* @__PURE__ */ new Map()}
-  
-  
-  
-  
-  
-  
-  
+var Vault = (_class8 = class _Vault {
   constructor(id, vault, tickDuration) {;_class8.prototype.__init12.call(this);
+    this.tickDuration = tickDuration;
     this.securitization = vault.securitization.toBigInt();
-    this.securitizationRatio = convertFixedU128ToBigNumber(
-      vault.securitizationRatio.toBigInt()
-    );
+    this.securitizationRatio = convertFixedU128ToBigNumber(vault.securitizationRatio.toBigInt());
     this.argonsLocked = vault.argonsLocked.toBigInt();
     this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
     if (vault.argonsScheduledForRelease.size > 0) {
@@ -1357,24 +1304,33 @@ var Vault = (_class8 = class {
         )
       };
     }
-    this.openedDate = vault.openedTick ? new Date(vault.openedTick.toNumber() * tickDuration) : /* @__PURE__ */ new Date();
+    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();
     return this.securitization - recoverySecuritization - this.argonsLocked + reLockable;
   }
   getRelockCapacity() {
-    return [...this.argonsScheduledForRelease.values()].reduce(
-      (acc, val) => acc + val,
-      0n
-    );
+    return [...this.argonsScheduledForRelease.values()].reduce((acc, val) => acc + val, 0n);
   }
   recoverySecuritization() {
     const reserved = new (0, BN.default)(1).div(this.securitizationRatio);
-    return this.securitization - BigInt(
-      reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2)
-    );
+    return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
   }
   minimumSecuritization() {
     return BigInt(
@@ -1387,9 +1343,7 @@ var Vault = (_class8 = class {
     if (this.securitizationRatio.toNumber() > 2) {
       maxRatio = BN.default.call(void 0, 2);
     }
-    return BigInt(
-      maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2)
-    );
+    return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
   }
   /**
    * Returns the amount of Argons available to match per liquidity pool
@@ -1402,6 +1356,65 @@ var Vault = (_class8 = class {
     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) {
+    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());
+    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");
+    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);
+      }
+    }
+    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 });
+    let vaultId;
+    for (const event of result.events) {
+      if (client.events.vaults.VaultCreated.is(event)) {
+        vaultId = event.data.vaultId.toNumber();
+        break;
+      }
+    }
+    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");
+    }
+    const tickDuration = await _asyncNullishCoalesce(config.tickDurationMillis, async () => ( await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber())));
+    return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+  }
 }, _class8);
 
 // src/VaultMonitor.ts
@@ -1452,7 +1465,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 = blockHeader.hash.toU8a();
+    const blockHash = Buffer.from(blockHeader.hash);
     console.log(
       `${justPrint ? "Run" : "Started"} at block ${blockHeader.number} - ${blockHeader.hash.toHuman()}`
     );
@@ -1508,9 +1521,7 @@ var VaultMonitor = (_class9 = class {
     if (this.shouldLog) {
       console.log(`Waiting for vault ${vaultId} to activate ${activationDate}`);
     }
-    await new Promise(
-      (resolve) => setTimeout(resolve, activationDate.getTime() - Date.now())
-    );
+    await new Promise((resolve) => setTimeout(resolve, activationDate.getTime() - Date.now()));
     const client = await this.mainchain;
     let isReady = false;
     while (!isReady) {
@@ -1529,10 +1540,7 @@ var VaultMonitor = (_class9 = class {
   }
   async onVaultsUpdated(blockHash, vaultIds) {
     await this.reloadVaultsAt([...vaultIds], blockHash).catch((err) => {
-      console.error(
-        `Failed to reload vault ${[...vaultIds]} at block ${blockHash}:`,
-        err
-      );
+      console.error(`Failed to reload vault ${[...vaultIds]} at block ${blockHash}:`, err);
     });
     this.printVaults();
   }
@@ -1644,10 +1652,7 @@ var CohortBidderHistory = (_class10 = class _CohortBidderHistory {
     }
     this.stats.seatsWon = winningBids;
     this.stats.totalArgonsBid = totalArgonsBid;
-    this.stats.lastBlockNumber = Math.max(
-      blockNumber,
-      this.stats.lastBlockNumber
-    );
+    this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
     const historyEntry = {
       cohortStartingFrameId: this.cohortStartingFrameId,
       blockNumber,
@@ -1662,9 +1667,7 @@ var CohortBidderHistory = (_class10 = class _CohortBidderHistory {
     }
     if (hasDiffs) {
       nextEntrants.forEach(({ address, bid }, i) => {
-        const prevBidIndex = this.lastBids.findIndex(
-          (y) => y.address === address
-        );
+        const prevBidIndex = this.lastBids.findIndex((y) => y.address === address);
         const entry = {
           address,
           bidAmount: bid,
@@ -1695,24 +1698,14 @@ var CohortBidderHistory = (_class10 = class _CohortBidderHistory {
     return historyEntry;
   }
   onBidResult(historyEntry, param) {
-    const {
-      txFeePlusTip,
-      bidPerSeat,
-      bidsAttempted,
-      successfulBids,
-      blockNumber,
-      bidError
-    } = 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
-      );
+      this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
     }
     if (historyEntry.myBidsPlaced) {
       historyEntry.myBidsPlaced.failureReason = bidError;
@@ -1780,14 +1773,12 @@ var CohortBidder = (_class11 = class {
     if (nextFrameId.toNumber() === this.cohortStartingFrameId && isBiddingOpen.isTrue) {
       console.log("Bidding is still open, waiting for it to close");
       await new Promise(async (resolve) => {
-        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen(
-          (isOpen) => {
-            if (isOpen.isFalse) {
-              unsub();
-              resolve();
-            }
+        const unsub = await client.query.miningSlot.isNextSlotBiddingOpen((isOpen) => {
+          if (isOpen.isFalse) {
+            unsub();
+            resolve();
           }
-        );
+        });
       });
     }
     void await this.pendingRequest;
@@ -1852,14 +1843,9 @@ var CohortBidder = (_class11 = class {
     const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
     const historyEntry = this.history.trackChange(bids, blockNumber, tick);
     if (this.pendingRequest) return;
-    const ticksSinceLastBid = Math.floor(
-      (Date.now() - this.lastBidTime) / this.millisPerTick
-    );
+    const ticksSinceLastBid = Math.floor((Date.now() - this.lastBidTime) / this.millisPerTick);
     if (ticksSinceLastBid < this.options.bidDelay) {
-      this.retryTimeout = setTimeout(
-        () => void this.checkCurrentSeats(),
-        this.millisPerTick
-      );
+      this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), this.millisPerTick);
       return;
     }
     console.log(
@@ -1907,15 +1893,9 @@ var CohortBidder = (_class11 = class {
     }
     if (nextBid < lowestBid) {
       console.log(
-        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(
-          lowestBid
-        )}.`
-      );
-      this.history.maybeReducingSeats(
-        winningBids,
-        "MaxBidTooLow" /* MaxBidTooLow */,
-        historyEntry
+        `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(lowestBid)}.`
       );
+      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
     if (nextBid - lowestBid < MIN_INCREMENT) {
@@ -1927,11 +1907,7 @@ var CohortBidder = (_class11 = class {
           maxBid: formatArgons(this.options.maxBid)
         }
       );
-      this.history.maybeReducingSeats(
-        winningBids,
-        "MaxBidTooLow" /* MaxBidTooLow */,
-        historyEntry
-      );
+      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
     const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
@@ -2000,10 +1976,7 @@ var CohortBidder = (_class11 = class {
       if (bidError) throw bidError;
     } catch (err) {
       this.lastBidTime = prevLastBidTime;
-      console.error(
-        `Error bidding for cohort ${this.cohortStartingFrameId}:`,
-        err
-      );
+      console.error(`Error bidding for cohort ${this.cohortStartingFrameId}:`, err);
       clearTimeout(this.retryTimeout);
       this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), 1e3);
     } finally {
@@ -2057,11 +2030,7 @@ var BidPool = (_class12 = class {
       const rawVault = rawVaults[i];
       if (rawVault.isNone) continue;
       const vaultId = vaultIds[i];
-      this.vaultsById[vaultId] = new Vault(
-        vaultId,
-        rawVault.unwrap(),
-        this.tickDuration
-      );
+      this.vaultsById[vaultId] = new Vault(vaultId, rawVault.unwrap(), this.tickDuration);
     }
     const vaults = Object.entries(this.vaultsById);
     const newSecuritization = [];
@@ -2084,16 +2053,13 @@ var BidPool = (_class12 = class {
   }
   async getBidPool() {
     const client = await this.client;
-    const balanceBytes = await client.rpc.state.call(
-      "MiningSlotApi_bid_pool",
-      ""
-    );
+    const balanceBytes = await client.rpc.state.call("MiningSlotApi_bid_pool", "");
     const balance = client.createType("U128", balanceBytes);
     return balance.toBigInt();
   }
   async loadAt(blockHash) {
     const client = await this.client;
-    blockHash ??= (await client.rpc.chain.getHeader()).hash.toU8a();
+    blockHash ??= Buffer.from((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());
@@ -2105,22 +2071,14 @@ var BidPool = (_class12 = class {
       this.loadFrameData(FrameIdNumber, funds);
     }
     for (const entrant of await api.query.liquidityPools.capitalActive()) {
-      this.setVaultFrameData(
-        entrant.frameId.toNumber(),
-        entrant.vaultId.toNumber(),
-        {
-          activatedCapital: entrant.activatedCapital.toBigInt()
-        }
-      );
+      this.setVaultFrameData(entrant.frameId.toNumber(), entrant.vaultId.toNumber(), {
+        activatedCapital: entrant.activatedCapital.toBigInt()
+      });
     }
     for (const entrant of await api.query.liquidityPools.capitalRaising()) {
-      this.setVaultFrameData(
-        entrant.frameId.toNumber(),
-        entrant.vaultId.toNumber(),
-        {
-          activatedCapital: entrant.activatedCapital.toBigInt()
-        }
-      );
+      this.setVaultFrameData(entrant.frameId.toNumber(), entrant.vaultId.toNumber(), {
+        activatedCapital: entrant.activatedCapital.toBigInt()
+      });
     }
     await this.onVaultsUpdated(blockHash, new Set(vaultIds));
     this.print();
@@ -2128,10 +2086,7 @@ var BidPool = (_class12 = class {
   async watch() {
     await this.loadAt();
     await this.blockWatch.start();
-    this.blockWatch.events.on(
-      "vaults-updated",
-      (b, v) => this.onVaultsUpdated(b.hash, v)
-    );
+    this.blockWatch.events.on("vaults-updated", (b, v) => this.onVaultsUpdated(b.hash, v));
     const api = await this.client;
     this.blockWatch.events.on("event", async (_, event) => {
       if (api.events.liquidityPools.BidPoolDistributed.is(event)) {
@@ -2166,25 +2121,13 @@ var BidPool = (_class12 = class {
         api.query.liquidityPools.capitalActive,
         api.query.liquidityPools.capitalRaising
       ],
-      async ([
-        _bids,
-        nextFrameId,
-        openVaultBidPoolCapital,
-        nextPoolCapital
-      ]) => {
+      async ([_bids, nextFrameId, openVaultBidPoolCapital, nextPoolCapital]) => {
         this.bidPoolAmount = await this.getBidPool();
         this.nextFrameId = nextFrameId.toNumber();
-        for (const entrant of [
-          ...openVaultBidPoolCapital,
-          ...nextPoolCapital
-        ]) {
-          this.setVaultFrameData(
-            entrant.frameId.toNumber(),
-            entrant.vaultId.toNumber(),
-            {
-              activatedCapital: entrant.activatedCapital.toBigInt()
-            }
-          );
+        for (const entrant of [...openVaultBidPoolCapital, ...nextPoolCapital]) {
+          this.setVaultFrameData(entrant.frameId.toNumber(), entrant.vaultId.toNumber(), {
+            activatedCapital: entrant.activatedCapital.toBigInt()
+          });
         }
         this.printDebounce();
       }
@@ -2338,10 +2281,7 @@ Raising Funds (Frame ${this.nextFrameId + 1}):`);
     this.poolVaultCapitalByFrame[frameId][vaultId] ??= {
       activatedCapital: _nullishCoalesce(_nullishCoalesce(data.activatedCapital, () => ( _optionalChain([data, 'access', _64 => _64.contributors, 'optionalAccess', _65 => _65.reduce, 'call', _66 => _66((a, b) => a + b.amount, 0n)]))), () => ( 0n))
     };
-    Object.assign(
-      this.poolVaultCapitalByFrame[frameId][vaultId],
-      filterUndefined(data)
-    );
+    Object.assign(this.poolVaultCapitalByFrame[frameId][vaultId], filterUndefined(data));
   }
   createBondCapitalTable(total, contributors, title = "Total") {
     const table = new (0, _consoletableprinter.Table)({
@@ -2380,9 +2320,7 @@ Raising Funds (Frame ${this.nextFrameId + 1}):`);
       }
       this.setVaultFrameData(frameId, vaultIdNumber, {
         earnings: fund.distributedProfits.isSome ? fund.distributedProfits.unwrap().toBigInt() : void 0,
-        vaultSharingPercent: convertPermillToBigNumber(
-          fund.vaultSharingPercent.toBigInt()
-        ),
+        vaultSharingPercent: convertPermillToBigNumber(fund.vaultSharingPercent.toBigInt()),
         contributors
       });
     }
@@ -2395,58 +2333,418 @@ var BitcoinLocks = class _BitcoinLocks {
   constructor(client) {
     this.client = client;
   }
+  async getUtxoIdFromEvents(events) {
+    const client = await this.client;
+    for (const event of events) {
+      if (client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
+        return event.data.utxoId.toNumber();
+      }
+    }
+    return void 0;
+  }
   async getMarketRate(satoshis) {
     const client = await this.client;
     const sats = client.createType("U64", satoshis.toString());
-    const marketRate = await client.rpc.state.call(
-      "BitcoinApis_market_rate",
-      sats.toHex(true)
-    );
+    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 buildBitcoinLockTx(args) {
-    const { vaultId, keypair, bitcoinXpub, tip } = args;
-    let amount = args.amount;
-    const marketRatePerBitcoin = await this.getMarketRate(100000000n);
+  async getRedemptionRate(satoshis) {
+    const client = await 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 = await this.client;
+    const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
+    return {
+      releaseExpirationBlocks: client.consts.bitcoinLocks.lockReleaseCosignDeadlineBlocks.toNumber(),
+      tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
+      bitcoinNetwork
+    };
+  }
+  async getBitcoinConfirmedBlockHeight() {
     const client = await this.client;
-    const account = await client.query.system.account(keypair.address);
-    const freeBalance = account.data.free.toBigInt();
-    let availableBalance = freeBalance;
-    if (args.reducedBalanceBy) {
-      availableBalance -= args.reducedBalanceBy;
-    }
-    const satoshisNeeded = amount * SATS_PER_BTC / marketRatePerBitcoin - 500n;
-    const tx = client.tx.bitcoinLocks.initialize(
+    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _67 => _67.value, 'optionalAccess', _68 => _68.blockHeight, 'access', _69 => _69.toNumber, 'call', _70 => _70()]), () => ( 0)));
+  }
+  /**
+   * Gets the UTXO reference by ID.
+   * @param utxoId - The UTXO ID to look up.
+   * @param atHeight - Optional 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, atHeight) {
+    let client = await this.client;
+    if (atHeight !== void 0) {
+      const blockHash = await client.query.system.blockHash(atHeight);
+      client = await client.at(blockHash);
+    }
+    const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
+    if (!refRaw) {
+      return;
+    }
+    const ref = refRaw.unwrap();
+    const txid = Buffer.from(ref.txid).toString("hex");
+    const btcTxid = Buffer.from(ref.txid.reverse()).toString("hex");
+    const vout = ref.outputIndex.toNumber();
+    return { txid: `0x${txid}`, vout, bitcoinTxid: `0x${btcTxid}` };
+  }
+  async getReleaseRequest(utxoId, atHeight) {
+    let client = await this.client;
+    if (atHeight !== void 0) {
+      const blockHash = await client.query.system.blockHash(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()
+        };
+      }
+    }
+    return void 0;
+  }
+  async submitVaultSignature(args) {
+    const { utxoId, vaultSignature, argonKeyring } = args;
+    const client = await this.client;
+    if (!vaultSignature || vaultSignature.byteLength < 71 || vaultSignature.byteLength > 73) {
+      throw new Error(
+        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 71-73 bytes.`
+      );
+    }
+    const signature = `0x${vaultSignature.toString("hex")}`;
+    const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
+    const submitter = new TxSubmitter(client, tx, argonKeyring);
+    return await submitter.submit({ waitForBlock: true });
+  }
+  async getBitcoinLock(utxoId) {
+    const client = await this.client;
+    const utxoRaw = await client.query.bitcoinLocks.locksByUtxoId(utxoId);
+    if (!utxoRaw.isSome) {
+      return;
+    }
+    const utxo = utxoRaw.unwrap();
+    const p2shBytesPrefix = "0020";
+    const wscriptHash = utxo.utxoScriptPubkey.asP2wsh.wscriptHash.toHex().replace("0x", "");
+    const p2wshScriptHashHex = `0x${p2shBytesPrefix}${wscriptHash}`;
+    const vaultId = utxo.vaultId.toNumber();
+    const lockPrice = utxo.lockPrice.toBigInt();
+    const ownerAccount = utxo.ownerAccount.toHuman();
+    const satoshis = utxo.satoshis.toBigInt();
+    const vaultPubkey = utxo.vaultPubkey.toHex();
+    const vaultClaimPubkey = utxo.vaultClaimPubkey.toHex();
+    const ownerPubkey = utxo.ownerPubkey.toHex();
+    const [fingerprint, cosign_hd_index, claim_hd_index] = utxo.vaultXpubSources;
+    const vaultXpubSources = {
+      parentFingerprint: Buffer.from(fingerprint),
+      cosignHdIndex: cosign_hd_index.toNumber(),
+      claimHdIndex: claim_hd_index.toNumber()
+    };
+    const vaultClaimHeight = utxo.vaultClaimHeight.toNumber();
+    const openClaimHeight = utxo.openClaimHeight.toNumber();
+    const createdAtHeight = utxo.createdAtHeight.toNumber();
+    const isVerified = utxo.isVerified.toJSON();
+    const isRejectedNeedsRelease = utxo.isRejectedNeedsRelease.toJSON();
+    const fundHoldExtensionsByBitcoinExpirationHeight = Object.fromEntries(
+      [...utxo.fundHoldExtensions.entries()].map(([x, y]) => [x.toNumber(), y.toBigInt()])
+    );
+    return {
+      utxoId,
+      p2wshScriptHashHex,
       vaultId,
-      satoshisNeeded,
-      bitcoinXpub
+      lockPrice,
+      ownerAccount,
+      satoshis,
+      vaultPubkey,
+      vaultClaimPubkey,
+      ownerPubkey,
+      vaultXpubSources,
+      vaultClaimHeight,
+      openClaimHeight,
+      createdAtHeight,
+      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 = await 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) {
+            _optionalChain([unsub, 'optionalCall', _71 => _71()]);
+            clearTimeout(timeout);
+            resolve({ signature, blockHeight: atHeight });
+          }
+        }).catch((err) => {
+          console.error(`Error checking for cosign signature at height ${atHeight}:`, err);
+        });
+      });
+      if (waitForSignatureMillis !== -1) {
+        timeout = setTimeout(() => {
+          _optionalChain([unsub, 'optionalCall', _72 => _72()]);
+          reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${utxoId}`));
+        }, waitForSignatureMillis);
+      }
+    });
+  }
+  async blockHashAtHeight(atHeight) {
+    const client = await this.client;
+    for (let i = 0; i < 10; i++) {
+      const currentHeight = await client.query.system.number().then((x) => x.toNumber());
+      if (atHeight > currentHeight) {
+        console.warn(
+          `Requested block height ${atHeight} is greater than current height ${currentHeight}. Retrying...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        continue;
+      }
+      const hash = await client.query.system.blockHash(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));
+        continue;
+      }
+      return hash;
+    }
+    return void 0;
+  }
+  async getVaultCosignSignature(utxoId, atHeight) {
+    const client = await 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 Buffer.from(signature);
+        }
+      }
+    }
+    return void 0;
+  }
+  async findPendingMints(utxoId) {
+    const client = await this.client;
+    const pendingMint = await 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, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
+    const client = await this.client;
+    if (ownerBitcoinPubkey.length !== 33) {
+      throw new Error(
+        `Invalid Bitcoin key length: ${ownerBitcoinPubkey.length}. Must be a compressed pukey (33 bytes).`
+      );
+    }
+    const tx = client.tx.bitcoinLocks.initialize(vault.vaultId, satoshis, ownerBitcoinPubkey);
+    const submitter = new TxSubmitter(
+      client,
+      client.tx.bitcoinLocks.initialize(vault.vaultId, satoshis, ownerBitcoinPubkey),
+      argonKeyring
     );
-    const existentialDeposit = client.consts.balances.existentialDeposit.toBigInt();
-    const finalTip = _nullishCoalesce(tip, () => ( 0n));
-    const fees = await tx.paymentInfo(keypair.address, { tip });
-    const txFee = fees.partialFee.toBigInt();
-    const tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
-    const rawVault = await client.query.vaults.vaultsById(vaultId);
-    const vault = new Vault(vaultId, rawVault.unwrap(), tickDuration);
-    const btcFee = vault.calculateBitcoinFee(amount);
-    const totalCharge = txFee + finalTip + btcFee;
-    if (amount + totalCharge + existentialDeposit > availableBalance) {
-      throw new Error("Insufficient balance to lock bitcoins");
+    const marketPrice = await this.getMarketRate(BigInt(satoshis));
+    const securityFee = vault.calculateBitcoinFee(marketPrice);
+    const { canAfford, availableBalance, txFee } = await submitter.canAfford({
+      tip,
+      unavailableBalance: securityFee + (_nullishCoalesce(args.reducedBalanceBy, () => ( 0n))),
+      includeExistentialDeposit: true
+    });
+    if (!canAfford) {
+      throw new Error(
+        `Insufficient funds to initialize lock. Available: ${formatArgons(availableBalance)}, Required: ${satoshis}`
+      );
     }
-    console.log(
-      `Locking ${satoshisNeeded} satoshis in vault ${vaultId} with market rate of ${formatArgons(marketRatePerBitcoin)}/btc. Xpub: ${bitcoinXpub}`
+    return { tx, securityFee, txFee };
+  }
+  async initializeLock(args) {
+    const { argonKeyring, tip = 0n } = 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 });
+    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));
+    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, securityFee };
+  }
+  async requiredSatoshisForArgonLiquidity(argonAmount) {
+    const marketRatePerBitcoin = await this.getMarketRate(SATS_PER_BTC);
+    return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
+  }
+  async requestRelease(args) {
+    const client = await this.client;
+    const {
+      lock,
+      releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
+      argonKeyring,
+      tip
+    } = 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
+    );
+    let redemptionPrice = await this.getRedemptionRate(lock.satoshis);
+    if (redemptionPrice > lock.lockPrice) {
+      redemptionPrice = lock.lockPrice;
+    }
+    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)}`
+      );
+    }
+    const txResult = await submitter.submit({ waitForBlock: true, logResults: true, tip });
+    const blockHash = await txResult.inBlockPromise;
+    const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
+    return {
+      blockHash,
+      blockHeight
+    };
+  }
+  async releasePrice(satoshis, lockPrice) {
+    const client = await this.client;
+    const redemptionRate = await this.getRedemptionRate(satoshis);
+    if (redemptionRate > lockPrice) {
+      return redemptionRate;
+    }
+    return lockPrice;
+  }
+  async getRatchetPrice(lock, vault) {
+    const { createdAtHeight, vaultClaimHeight, lockPrice, satoshis } = lock;
+    const client = await this.client;
+    const marketRate = await this.getMarketRate(BigInt(satoshis));
+    let ratchetingFee = vault.terms.bitcoinBaseFee;
+    let burnAmount = 0n;
+    if (marketRate > lockPrice) {
+      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(lock.satoshis, lockPrice);
+    }
+    return {
+      ratchetingFee,
+      burnAmount,
+      marketRate
+    };
+  }
+  async ratchet(args) {
+    const { lock, argonKeyring, tip = 0n, vault } = args;
+    const client = await this.client;
+    const ratchetPrice = await this.getRatchetPrice(lock, 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 submission = await txSubmitter.submit({
+      waitForBlock: true,
+      tip
+    });
+    const ratchetEvent = submission.events.find(
+      (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
     );
-    return { tx, txFee, btcFee, satoshis: satoshisNeeded, freeBalance };
+    if (!ratchetEvent) {
+      throw new Error(`Ratchet event not found in transaction events`);
+    }
+    const blockHash = await submission.inBlockPromise;
+    const api = await client.at(blockHash);
+    const blockHeight = await api.query.system.number().then((x) => x.toNumber());
+    const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
+    const { amountBurned, newLockPrice, originalLockPrice } = ratchetEvent.data;
+    let mintAmount = newLockPrice.toBigInt();
+    if (newLockPrice > originalLockPrice) {
+      mintAmount -= originalLockPrice.toBigInt();
+    }
+    return {
+      txFee: _nullishCoalesce(submission.finalFee, () => ( 0n)),
+      securityFee: ratchetPrice.ratchetingFee,
+      pendingMint: mintAmount,
+      newLockPrice: newLockPrice.toBigInt(),
+      burned: amountBurned.toBigInt(),
+      blockHeight,
+      bitcoinBlockHeight
+    };
   }
   static async waitForSpace(accountset, options) {
     const { argonAmount, bitcoinXpub, maxLockFee, tip = 0n } = options;
     const vaults = new VaultMonitor(accountset, {
       bitcoinSpaceAvailable: argonAmount
     });
+    const bitcoinXpubBuffer = Buffer.from(bitcoinXpub.replace(/^0x(.+)/, "$1"), "hex");
     return new Promise(async (resolve, reject) => {
       vaults.events.on("bitcoin-space-above", async (vaultId, amount) => {
         const vault = vaults.vaultsById[vaultId];
@@ -2462,27 +2760,23 @@ var BitcoinLocks = class _BitcoinLocks {
         }
         try {
           const bitcoinLock = new _BitcoinLocks(accountset.client);
-          const { tx, satoshis, btcFee, txFee } = await bitcoinLock.buildBitcoinLockTx({
-            vaultId,
-            keypair: accountset.txSubmitterPair,
-            amount: argonAmount,
-            bitcoinXpub,
+          let satoshis = await bitcoinLock.requiredSatoshisForArgonLiquidity(amount);
+          satoshis -= _nullishCoalesce(options.satoshiWiggleRoomForDynamicPrice, () => ( 500n));
+          const { txResult, lock, securityFee } = await bitcoinLock.initializeLock({
+            vault,
+            satoshis,
+            argonKeyring: accountset.txSubmitterPair,
+            ownerBitcoinPubkey: bitcoinXpubBuffer,
             tip
           });
-          const result = await accountset.tx(tx).then((x) => x.submit({ waitForBlock: true, tip }));
-          const client = await accountset.client;
-          const utxoId = _optionalChain([result, 'access', _67 => _67.events, 'access', _68 => _68.find, 'call', _69 => _69((x) => client.events.bitcoinLocks.BitcoinLockCreated.is(x)), 'optionalAccess', _70 => _70.data, 'access', _71 => _71.utxoId, 'optionalAccess', _72 => _72.toNumber, 'call', _73 => _73()]);
-          if (!utxoId) {
-            throw new Error("Failed to find UTXO ID");
-          }
           resolve({
             satoshis,
             argons: argonAmount,
             vaultId,
-            btcFee,
-            txFee,
-            finalizedPromise: result.finalizedPromise,
-            utxoId
+            securityFee,
+            txFee: txResult.finalFee,
+            finalizedPromise: txResult.finalizedPromise,
+            utxoId: lock.utxoId
           });
         } catch (err) {
           console.error("Error submitting bitcoin lock tx:", err);
@@ -2515,7 +2809,7 @@ async function waitForLoad() {
 }
 async function getClient(host) {
   let provider;
-  if (host.startsWith("http:")) {
+  if (host.startsWith("http")) {
     provider = new (0, _api.HttpProvider)(host);
   } else {
     provider = new (0, _api.WsProvider)(host);
@@ -2563,5 +2857,9 @@ 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.convertFixedU128ToBigNumber = convertFixedU128ToBigNumber; exports.convertPermillToBigNumber = convertPermillToBigNumber; 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.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-CHGCEO2U.cjs.map
+
+
+
+
+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