@argonprotocol/mainchain 1.3.7 → 1.3.9

package/lib/index.js

@@ -1,102 +1,1133 @@
+// src/interfaces/augment-api-consts.ts
+import "@polkadot/api-base/types/consts";
+
+// src/interfaces/augment-api-errors.ts
+import "@polkadot/api-base/types/errors";
+
+// src/interfaces/augment-api-events.ts
+import "@polkadot/api-base/types/events";
+
+// src/interfaces/augment-api-query.ts
+import "@polkadot/api-base/types/storage";
+
+// src/interfaces/augment-api-tx.ts
+import "@polkadot/api-base/types/submittable";
+
+// src/interfaces/augment-api-rpc.ts
+import "@polkadot/rpc-core/types/jsonrpc";
+
+// src/interfaces/augment-api-runtime.ts
+import "@polkadot/api-base/types/calls";
+
+// src/interfaces/augment-types.ts
+import "@polkadot/types/types/registry";
+
+// src/index.ts
+import { ApiPromise, HttpProvider, Keyring, WsProvider } from "@polkadot/api";
+import { cryptoWaitReady, decodeAddress, mnemonicGenerate } from "@polkadot/util-crypto";
+
+// src/WageProtector.ts
+var WageProtector = class _WageProtector {
+  constructor(latestCpi) {
+    this.latestCpi = latestCpi;
+  }
+  /**
+   * Converts the base wage to the current wage using the latest CPI snapshot
+   *
+   * @param baseWage The base wage to convert
+   * @returns The protected wage
+   */
+  getProtectedWage(baseWage) {
+    return baseWage * this.latestCpi.argonUsdTargetPrice / this.latestCpi.argonUsdPrice;
+  }
+  /**
+   * Subscribes to the current CPI and calls the callback function whenever the CPI changes
+   * @param client The ArgonClient to use
+   * @param callback The callback function to call when the CPI changes
+   * @returns An object with an unsubscribe function that can be called to stop the subscription
+   */
+  static async subscribe(client, callback) {
+    const unsubscribe = await client.query.priceIndex.current(async (cpi) => {
+      if (cpi.isNone) {
+        return;
+      }
+      const finalizedBlock = await client.rpc.chain.getFinalizedHead();
+      callback(
+        new _WageProtector({
+          argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
+          argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
+          finalizedBlock: new Uint8Array(finalizedBlock),
+          tick: cpi.value.tick.toBigInt()
+        })
+      );
+    });
+    return { unsubscribe };
+  }
+  /**
+   * Creates a new WageProtector instance by subscribing to the current CPI and waiting for the first value
+   * @param client The ArgonClient to use
+   */
+  static async create(client) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const { unsubscribe } = await _WageProtector.subscribe(client, (x) => {
+          resolve(x);
+          unsubscribe();
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+};
+
+// src/TxSubmitter.ts
+function logExtrinsicResult(result) {
+  const json = result.status.toJSON();
+  const status = Object.keys(json)[0];
+  console.debug('Transaction update: "%s"', status, json[status]);
+}
+var TxSubmitter = class {
+  constructor(client, tx, pair) {
+    this.client = client;
+    this.tx = tx;
+    this.pair = pair;
+  }
+  async feeEstimate(tip) {
+    const { partialFee } = await this.tx.paymentInfo(this.pair, { tip });
+    return partialFee.toBigInt();
+  }
+  async canAfford(options = {}) {
+    const { tip, unavailableBalance } = options;
+    const account = await this.client.query.system.account(this.pair.address);
+    let availableBalance = account.data.free.toBigInt();
+    const userBalance = availableBalance;
+    if (unavailableBalance) {
+      availableBalance -= unavailableBalance;
+    }
+    const existentialDeposit = options.includeExistentialDeposit ? this.client.consts.balances.existentialDeposit.toBigInt() : 0n;
+    const fees = await this.feeEstimate(tip);
+    const totalCharge = fees + (tip ?? 0n);
+    const canAfford = availableBalance >= totalCharge + existentialDeposit;
+    return { canAfford, availableBalance: userBalance, txFee: fees };
+  }
+  async submit(options = {}) {
+    const { logResults, waitForBlock, useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
+    const result = new TxResult(this.client, logResults);
+    result.txProgressCallback = options.txProgressCallback;
+    let toHuman = this.tx.toHuman().method;
+    const txString = [];
+    let api = formatCall(toHuman);
+    const args = [];
+    if (api === "proxy.proxy") {
+      toHuman = toHuman.args.call;
+      txString.push("Proxy");
+      api = formatCall(toHuman);
+    }
+    if (api.startsWith("utility.batch")) {
+      const calls = toHuman.args.calls.map(formatCall).join(", ");
+      txString.push(`Batch[${calls}]`);
+    } else {
+      txString.push(api);
+      args.push(toHuman.args);
+    }
+    args.unshift(txString.join("->"));
+    if (useLatestNonce && !apiOptions.nonce) {
+      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
+    }
+    console.log("Submitting transaction from %s:", this.pair.address, ...args);
+    await this.tx.signAndSend(this.pair, apiOptions, result.onResult.bind(result));
+    if (waitForBlock) {
+      await result.inBlockPromise;
+    }
+    return result;
+  }
+};
+function formatCall(call) {
+  return `${call.section}.${call.method}`;
+}
+var TxResult = class {
+  constructor(client, shouldLog = false) {
+    this.client = client;
+    this.shouldLog = shouldLog;
+    this.inBlockPromise = new Promise((resolve, reject) => {
+      this.inBlockResolve = resolve;
+      this.inBlockReject = reject;
+    });
+    this.finalizedPromise = new Promise((resolve, reject) => {
+      this.finalizedResolve = resolve;
+      this.finalizedReject = reject;
+    });
+    this.inBlockPromise.catch(() => null);
+    this.finalizedPromise.catch(() => null);
+  }
+  inBlockPromise;
+  finalizedPromise;
+  status;
+  events = [];
+  /**
+   * The index of the batch that was interrupted, if any.
+   */
+  batchInterruptedIndex;
+  includedInBlock;
+  /**
+   * The final fee paid for the transaction, including the fee tip.
+   */
+  finalFee;
+  /**
+   * The fee tip paid for the transaction.
+   */
+  finalFeeTip;
+  txProgressCallback;
+  inBlockResolve;
+  inBlockReject;
+  finalizedResolve;
+  finalizedReject;
+  onResult(result) {
+    this.status = result.status;
+    if (this.shouldLog) {
+      logExtrinsicResult(result);
+    }
+    const { events, status, dispatchError, isFinalized } = result;
+    if (status.isInBlock) {
+      this.includedInBlock = new Uint8Array(status.asInBlock);
+      let encounteredError = dispatchError;
+      let batchErrorIndex;
+      for (const event of events) {
+        this.events.push(event.event);
+        if (this.client.events.utility.BatchInterrupted.is(event.event)) {
+          batchErrorIndex = event.event.data[0].toNumber();
+          this.batchInterruptedIndex = batchErrorIndex;
+          encounteredError = event.event.data[1];
+        }
+        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);
+        this.reject(error);
+      } else {
+        this.inBlockResolve(new Uint8Array(status.asInBlock));
+      }
+    }
+    if (isFinalized) {
+      this.finalizedResolve(status.asFinalized);
+    }
+    if (this.txProgressCallback) {
+      let percent = 0;
+      if (result.status.isBroadcast) {
+        percent = 50;
+      } else if (result.status.isInBlock) {
+        percent = 100;
+      }
+      this.txProgressCallback(percent, this);
+    }
+  }
+  reject(error) {
+    this.inBlockReject(error);
+    this.finalizedReject(error);
+  }
+};
+
+// src/utils.ts
+import BigNumber, * as BN from "bignumber.js";
+var { ROUND_FLOOR } = BN;
+var MICROGONS_PER_ARGON = 1e6;
+function formatArgons(microgons) {
+  if (microgons === void 0 || microgons === null) return "na";
+  const isNegative = microgons < 0;
+  let format = BigNumber(microgons.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+  if (format.endsWith(".00")) {
+    format = format.slice(0, -3);
+  }
+  return `${isNegative ? "-" : ""}\u20B3${format}`;
+}
+async function gettersToObject(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+  const keys = [];
+  for (const key in obj) {
+    keys.push(key);
+  }
+  if (Symbol.iterator in obj) {
+    const iterableToArray = [];
+    for (const item of obj) {
+      iterableToArray.push(await gettersToObject(item));
+    }
+    return iterableToArray;
+  }
+  const result = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      continue;
+    }
+    const value = descriptor && descriptor.get ? descriptor.get.call(obj) : obj[key];
+    if (typeof value === "function") continue;
+    result[key] = await gettersToObject(value);
+  }
+  return result;
+}
+function dispatchErrorToString(client, error) {
+  let message = error.toString();
+  if (error.isModule) {
+    const decoded = client.registry.findMetaError(error.asModule);
+    const { docs, name, section } = decoded;
+    message = `${section}.${name}: ${docs.join(" ")}`;
+  }
+  return message;
+}
+var ExtrinsicError2 = class extends Error {
+  constructor(errorCode, details, batchInterruptedIndex) {
+    super(errorCode);
+    this.errorCode = errorCode;
+    this.details = details;
+    this.batchInterruptedIndex = batchInterruptedIndex;
+  }
+  toString() {
+    if (this.batchInterruptedIndex !== void 0) {
+      return `${this.errorCode} ${this.details ?? ""} (Batch interrupted at index ${this.batchInterruptedIndex})`;
+    }
+    return `${this.errorCode} ${this.details ?? ""}`;
+  }
+};
+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(error.toString(), void 0, batchInterruptedIndex);
+}
+function checkForExtrinsicSuccess(events, client) {
+  return new Promise((resolve, reject) => {
+    for (const { event } of events) {
+      if (client.events.system.ExtrinsicSuccess.is(event)) {
+        resolve();
+      } else if (client.events.system.ExtrinsicFailed.is(event)) {
+        const [dispatchError] = event.data;
+        let errorInfo = dispatchError.toString();
+        if (dispatchError.isModule) {
+          const decoded = client.registry.findMetaError(dispatchError.asModule);
+          errorInfo = `${decoded.section}.${decoded.name}`;
+        }
+        reject(new Error(`${event.section}.${event.method}:: ExtrinsicFailed:: ${errorInfo}`));
+      }
+    }
+  });
+}
+
+// src/keyringUtils.ts
+function keyringFromSuri(suri, cryptoType = "sr25519") {
+  return new Keyring({ type: cryptoType }).createFromUri(suri);
+}
+function createKeyringPair(opts) {
+  const { cryptoType } = opts;
+  const seed = mnemonicGenerate();
+  return keyringFromSuri(seed, cryptoType);
+}
+
+// src/header.ts
+function getTickFromHeader(client, header) {
+  for (const x of header.digest.logs) {
+    if (x.isPreRuntime) {
+      const [engineId, data] = x.asPreRuntime;
+      if (engineId.toString() === "aura") {
+        return client.createType("u64", data).toNumber();
+      }
+    }
+  }
+  return void 0;
+}
+function getAuthorFromHeader(client, header) {
+  for (const x of header.digest.logs) {
+    if (x.isPreRuntime) {
+      const [engineId, data] = x.asPreRuntime;
+      if (engineId.toString() === "pow_") {
+        return client.createType("AccountId32", data).toHuman();
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/Vault.ts
+import BigNumber2, * as BN2 from "bignumber.js";
+import bs58check from "bs58check";
+import { hexToU8a } from "@polkadot/util";
+var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
+var Vault = class _Vault {
+  constructor(id, vault, tickDuration) {
+    this.tickDuration = tickDuration;
+    this.vaultId = id;
+    this.openedTick = vault.openedTick.toNumber();
+    this.openedDate = new Date(this.openedTick * this.tickDuration);
+    this.argonsScheduledForRelease = /* @__PURE__ */ new Map();
+    this.load(vault);
+  }
+  securitization;
+  argonsLocked;
+  argonsPendingActivation;
+  argonsScheduledForRelease;
+  terms;
+  operatorAccountId;
+  isClosed;
+  vaultId;
+  pendingTerms;
+  pendingTermsChangeTick;
+  openedDate;
+  openedTick;
+  securitizationRatio;
+  load(vault) {
+    this.securitization = vault.securitization.toBigInt();
+    this.securitizationRatio = fromFixedNumber(
+      vault.securitizationRatio.toBigInt(),
+      FIXED_U128_DECIMALS
+    ).toNumber();
+    this.argonsLocked = vault.argonsLocked.toBigInt();
+    this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
+    if (vault.argonsScheduledForRelease.size > 0) {
+      this.argonsScheduledForRelease.clear();
+      for (const [tick, amount] of vault.argonsScheduledForRelease.entries()) {
+        this.argonsScheduledForRelease.set(tick.toNumber(), amount.toBigInt());
+      }
+    }
+    this.terms = {
+      bitcoinAnnualPercentRate: fromFixedNumber(
+        vault.terms.bitcoinAnnualPercentRate.toBigInt(),
+        FIXED_U128_DECIMALS
+      ),
+      bitcoinBaseFee: vault.terms.bitcoinBaseFee.toBigInt(),
+      treasuryProfitSharing: fromFixedNumber(
+        vault.terms.treasuryProfitSharing.toBigInt(),
+        PERMILL_DECIMALS
+      )
+    };
+    this.operatorAccountId = vault.operatorAccountId.toString();
+    this.isClosed = vault.isClosed.valueOf();
+    if (vault.pendingTerms.isSome) {
+      const [tickApply, terms] = vault.pendingTerms.value;
+      this.pendingTermsChangeTick = tickApply.toNumber();
+      this.pendingTerms = {
+        bitcoinAnnualPercentRate: fromFixedNumber(
+          terms.bitcoinAnnualPercentRate.toBigInt(),
+          FIXED_U128_DECIMALS
+        ),
+        bitcoinBaseFee: terms.bitcoinBaseFee.toBigInt(),
+        treasuryProfitSharing: fromFixedNumber(
+          vault.terms.treasuryProfitSharing.toBigInt(),
+          PERMILL_DECIMALS
+        )
+      };
+    }
+  }
+  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);
+  }
+  securitizationRatioBN() {
+    return new BigNumber2(this.securitizationRatio);
+  }
+  recoverySecuritization() {
+    const reserved = new BigNumber2(1).div(this.securitizationRatioBN());
+    return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
+  }
+  minimumSecuritization() {
+    return BigInt(
+      this.securitizationRatioBN().multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber2.ROUND_CEIL).toString()
+    );
+  }
+  activatedSecuritization() {
+    const activated = this.argonsLocked - this.argonsPendingActivation;
+    const maxRatio = BigNumber2(Math.min(this.securitizationRatio, 2));
+    return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
+  }
+  /**
+   * Returns the amount of Argons available to match per treasury pool
+   */
+  activatedSecuritizationPerSlot() {
+    const activated = this.activatedSecuritization();
+    return activated / 10n;
+  }
+  calculateBitcoinFee(amount) {
+    const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber2.ROUND_CEIL);
+    return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
+  }
+  static async get(client, vaultId, tickDurationMillis) {
+    const rawVault = await client.query.vaults.vaultsById(vaultId);
+    if (rawVault.isNone) {
+      throw new Error(`Vault with id ${vaultId} not found`);
+    }
+    const tickDuration = tickDurationMillis ?? 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,
+      doNotExceedBalance,
+      txProgressCallback
+    } = args;
+    let xpubBytes = hexToU8a(bitcoinXpub);
+    if (xpubBytes.length !== 78) {
+      if (bitcoinXpub.startsWith("xpub") || bitcoinXpub.startsWith("tpub") || bitcoinXpub.startsWith("zpub")) {
+        const bytes = bs58check.decode(bitcoinXpub);
+        if (bytes.length !== 78) {
+          throw new Error("Invalid Bitcoin xpub key length, must be 78 bytes");
+        }
+        xpubBytes = bytes;
+      }
+    }
+    const vaultParams = {
+      terms: {
+        // convert to fixed u128
+        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, FIXED_U128_DECIMALS),
+        bitcoinBaseFee: BigInt(baseFee),
+        treasuryProfitSharing: toFixedNumber(args.treasuryProfitSharing, PERMILL_DECIMALS)
+      },
+      securitizationRatio: toFixedNumber(securitizationRatio, FIXED_U128_DECIMALS),
+      securitization: BigInt(securitization),
+      bitcoinXpubkey: xpubBytes
+    };
+    const tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
+    if (doNotExceedBalance) {
+      const finalTip = tip ?? 0n;
+      let txFee = await tx.feeEstimate(finalTip);
+      while (txFee + finalTip + vaultParams.securitization > doNotExceedBalance) {
+        vaultParams.securitization = doNotExceedBalance - txFee - finalTip;
+        tx.tx = client.tx.vaults.create(vaultParams);
+        txFee = await tx.feeEstimate(finalTip);
+      }
+    }
+    const 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({
+      tip,
+      useLatestNonce: true,
+      waitForBlock: true,
+      txProgressCallback
+    });
+    await result.inBlockPromise;
+    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 = config.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    const vault = new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+    return { vault, txResult: result };
+  }
+};
+
+// src/convert.ts
+import BigNumber3 from "bignumber.js";
+function toFixedNumber(value, decimals) {
+  const factor = new BigNumber3(10).pow(decimals);
+  const bn = new BigNumber3(value);
+  const int = bn.times(factor).integerValue(BigNumber3.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
+}
+function fromFixedNumber(value, decimals = FIXED_U128_DECIMALS) {
+  const factor = new BigNumber3(10).pow(decimals);
+  const bn = new BigNumber3(value.toString());
+  return bn.div(factor);
+}
+var FIXED_U128_DECIMALS = 18;
+var PERMILL_DECIMALS = 6;
+
+// src/BitcoinLocks.ts
+import { u8aToHex } from "@polkadot/util";
+var SATS_PER_BTC = 100000000n;
+var BitcoinLocks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getUtxoIdFromEvents(events) {
+    for (const event of events) {
+      if (this.client.events.bitcoinLocks.BitcoinLockCreated.is(event)) {
+        return event.data.utxoId.toNumber();
+      }
+    }
+    return void 0;
+  }
+  async getMarketRate(priceIndex, satoshis) {
+    return priceIndex.getBtcMicrogonPrice(satoshis);
+  }
+  async getRedemptionRate(priceIndex, details) {
+    const { satoshis, peggedPrice } = details;
+    const satsPerArgon = Number(SATS_PER_BTC) / MICROGONS_PER_ARGON;
+    let price = Number(priceIndex.btcUsdPrice);
+    price = price / satsPerArgon * Number(satoshis);
+    if (peggedPrice !== void 0 && peggedPrice < price) {
+      price = Number(peggedPrice);
+    }
+    const r = Number(priceIndex.rValue);
+    let multiplier;
+    if (r >= 1) {
+      multiplier = 1;
+    } else if (r >= 0.9) {
+      multiplier = 20 * (r * r) - 38 * r + 19;
+    } else if (r >= 0.01) {
+      multiplier = (0.5618 * r + 0.3944) / r;
+    } else {
+      multiplier = 1 / r * (0.576 * r + 0.4);
+    }
+    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;
+    const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
+    return {
+      lockReleaseCosignDeadlineFrames: client.consts.bitcoinLocks.lockReleaseCosignDeadlineFrames.toNumber(),
+      pendingConfirmationExpirationBlocks: client.consts.bitcoinUtxos.maxPendingConfirmationBlocks.toNumber(),
+      tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
+      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()
+    };
+  }
+  async submitVaultSignature(args) {
+    const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
+    const client = this.client;
+    if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
+      throw new Error(
+        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
+      );
+    }
+    const signature = u8aToHex(vaultSignature);
+    const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
+    const submitter = new TxSubmitter(client, tx, argonKeyring);
+    return await submitter.submit({ txProgressCallback });
+  }
+  async getBitcoinLock(utxoId) {
+    const utxoRaw = await this.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 peggedPrice = utxo.peggedPrice.toBigInt();
+    const liquidityPromised = utxo.liquidityPromised.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: new Uint8Array(fingerprint),
+      cosignHdIndex: cosign_hd_index.toNumber(),
+      claimHdIndex: claim_hd_index.toNumber()
+    };
+    const securityFees = utxo.securityFees.toBigInt();
+    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,
+      peggedPrice,
+      liquidityPromised,
+      ownerAccount,
+      satoshis,
+      vaultPubkey,
+      vaultClaimPubkey,
+      ownerPubkey,
+      vaultXpubSources,
+      vaultClaimHeight,
+      openClaimHeight,
+      createdAtHeight,
+      securityFees,
+      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;
+    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.rpc.chain.getBlockHash(atHeight).then((x) => x.toHex());
+      if (hash === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        console.warn(`Block hash not found for height ${atHeight}. Retrying...`);
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        continue;
+      }
+      return hash;
+    }
+    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;
+    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 marketPrice = await this.getMarketRate(priceIndex, satoshis);
+    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),
+      includeExistentialDeposit: true
+    });
+    if (!canAfford) {
+      throw new Error(
+        `Insufficient funds to initialize lock. Available: ${formatArgons(availableBalance)}, Required: ${satoshis}`
+      );
+    }
+    return { tx, securityFee, txFee };
+  }
+  async getBitcoinLockFromTxResult(txResult) {
+    const client = this.client;
+    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;
+    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, tip = 0n, txProgressCallback } = args;
+    const client = 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(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,
+      txProgressCallback
+    } = 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)}`
+      );
+    }
+    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());
+    return {
+      blockHash,
+      blockHeight
+    };
+  }
+  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);
+    }
+    return {
+      ratchetingFee,
+      burnAmount,
+      marketRate
+    };
+  }
+  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 submission = await txSubmitter.submit({
+      waitForBlock: true,
+      tip,
+      txProgressCallback
+    });
+    const ratchetEvent = submission.events.find(
+      (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
+    );
+    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,
+      liquidityPromised: liquidityPromisedRaw,
+      newPeggedPrice,
+      originalPeggedPrice
+    } = ratchetEvent.data;
+    const liquidityPromised = liquidityPromisedRaw.toBigInt();
+    let mintAmount = liquidityPromised;
+    if (liquidityPromised > originalPeggedPrice.toBigInt()) {
+      mintAmount -= originalPeggedPrice.toBigInt();
+    }
+    return {
+      txFee: submission.finalFee ?? 0n,
+      securityFee: ratchetPrice.ratchetingFee,
+      pendingMint: mintAmount,
+      liquidityPromised,
+      newPeggedPrice: newPeggedPrice.toBigInt(),
+      burned: amountBurned.toBigInt(),
+      blockHeight,
+      bitcoinBlockHeight
+    };
+  }
+};
+
+// src/PriceIndex.ts
+import BigNumber4 from "bignumber.js";
+var PriceIndex = class {
+  btcUsdPrice;
+  argonotUsdPrice;
+  argonUsdPrice;
+  argonUsdTargetPrice;
+  argonTimeWeightedAverageLiquidity;
+  lastUpdatedTick;
+  async load(client) {
+    const current = await client.query.priceIndex.current();
+    if (!current.isSome) {
+      this.argonUsdPrice = void 0;
+      this.argonotUsdPrice = void 0;
+      this.btcUsdPrice = void 0;
+      this.argonUsdTargetPrice = void 0;
+      this.argonTimeWeightedAverageLiquidity = void 0;
+      this.lastUpdatedTick = void 0;
+      return this;
+    }
+    const value = current.unwrap();
+    this.btcUsdPrice = fromFixedNumber(value.btcUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonotUsdPrice = fromFixedNumber(value.argonotUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonUsdPrice = fromFixedNumber(value.argonUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonUsdTargetPrice = fromFixedNumber(
+      value.argonUsdTargetPrice.toBigInt(),
+      FIXED_U128_DECIMALS
+    );
+    this.argonTimeWeightedAverageLiquidity = fromFixedNumber(
+      value.argonTimeWeightedAverageLiquidity.toBigInt(),
+      FIXED_U128_DECIMALS
+    );
+    this.lastUpdatedTick = value.tick.toNumber();
+    return this;
+  }
+  getBtcMicrogonPrice(satoshis) {
+    if (this.btcUsdPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    const satoshiCents = this.btcUsdPrice.multipliedBy(satoshis).dividedBy(SATS_PER_BTC);
+    const microgons = satoshiCents.multipliedBy(MICROGONS_PER_ARGON).dividedBy(this.argonUsdPrice);
+    return BigInt(microgons.integerValue(BigNumber4.ROUND_DOWN).toString());
+  }
+  get rValue() {
+    if (this.argonUsdTargetPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    return this.argonUsdPrice.div(this.argonUsdTargetPrice);
+  }
+  get argonCpi() {
+    if (this.argonUsdTargetPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    const ratio = this.argonUsdTargetPrice.div(this.argonUsdPrice);
+    return ratio.minus(1);
+  }
+};
+
+// src/index.ts
+import { u8aToHex as u8aToHex2, hexToU8a as hexToU8a2, u8aEq } from "@polkadot/util";
+import { GenericEvent as GenericEvent2, GenericBlock, GenericAddress } from "@polkadot/types/generic";
 import {
-  AccountMiners,
-  AccountRegistry,
-  Accountset,
   BTreeMap,
-  BidPool,
-  BitcoinLocks,
-  BlockWatch,
-  Bool,
   Bytes,
-  CohortBidder,
   Compact,
   Enum,
-  ExtrinsicError,
-  FrameCalculator,
-  GenericAddress,
-  GenericBlock,
-  GenericEvent,
-  JsonExt,
-  Keyring,
-  MICROGONS_PER_ARGON,
-  MiningBids,
   Null,
   Option,
-  Range,
   Result,
-  SATS_PER_BTC,
+  Bool,
+  Tuple,
+  Range,
   Struct,
   Text,
-  Tuple,
-  TxResult,
-  TxSubmitter,
-  TypedEmitter,
   U256,
   U8aFixed,
-  Vault,
-  VaultMonitor,
   Vec,
-  WageProtector,
   bool,
-  checkForExtrinsicSuccess,
-  convertFixedU128ToBigNumber,
-  convertNumberToFixedU128,
-  convertNumberToPermill,
-  convertPermillToBigNumber,
-  createKeyringPair,
-  createNanoEvents,
-  decodeAddress,
-  dispatchErrorToExtrinsicError,
-  dispatchErrorToString,
-  eventDataToJson,
-  filterUndefined,
-  formatArgons,
-  formatPercent,
-  getAuthorFromHeader,
-  getClient,
-  getConfig,
-  getTickFromHeader,
-  gettersToObject,
-  hexToU8a,
   i128,
-  keyringFromSuri,
-  miniSecretFromUri,
-  mnemonicGenerate,
-  setConfig,
-  toFixedNumber,
   u128,
   u16,
   u32,
   u64,
-  u8,
-  u8aEq,
-  u8aToHex,
-  waitForLoad
-} from "./chunk-PXZPYJ4P.js";
+  u8
+} from "@polkadot/types-codec";
+async function waitForLoad() {
+  await cryptoWaitReady();
+}
+async function getClient(host, options) {
+  let provider;
+  if (host.startsWith("http")) {
+    provider = new HttpProvider(host);
+  } else {
+    provider = new WsProvider(host);
+  }
+  return await ApiPromise.create({ provider, noInitWarn: true, ...options ?? {} });
+}
 export {
-  AccountMiners,
-  AccountRegistry,
-  Accountset,
   BTreeMap,
-  BidPool,
   BitcoinLocks,
-  BlockWatch,
   Bool,
   Bytes,
-  CohortBidder,
   Compact,
   Enum,
-  ExtrinsicError,
-  FrameCalculator,
+  ExtrinsicError2 as ExtrinsicError,
+  FIXED_U128_DECIMALS,
   GenericAddress,
   GenericBlock,
-  GenericEvent,
-  JsonExt,
+  GenericEvent2 as GenericEvent,
   Keyring,
   MICROGONS_PER_ARGON,
-  MiningBids,
   Null,
   Option,
+  PERMILL_DECIMALS,
+  PriceIndex,
   Range,
   Result,
   SATS_PER_BTC,
@@ -105,39 +1136,27 @@ export {
   Tuple,
   TxResult,
   TxSubmitter,
-  TypedEmitter,
   U256,
   U8aFixed,
   Vault,
-  VaultMonitor,
   Vec,
   WageProtector,
   bool,
   checkForExtrinsicSuccess,
-  convertFixedU128ToBigNumber,
-  convertNumberToFixedU128,
-  convertNumberToPermill,
-  convertPermillToBigNumber,
   createKeyringPair,
-  createNanoEvents,
   decodeAddress,
   dispatchErrorToExtrinsicError,
   dispatchErrorToString,
-  eventDataToJson,
-  filterUndefined,
   formatArgons,
-  formatPercent,
+  fromFixedNumber,
   getAuthorFromHeader,
   getClient,
-  getConfig,
   getTickFromHeader,
   gettersToObject,
-  hexToU8a,
+  hexToU8a2 as hexToU8a,
   i128,
   keyringFromSuri,
-  miniSecretFromUri,
   mnemonicGenerate,
-  setConfig,
   toFixedNumber,
   u128,
   u16,
@@ -145,7 +1164,7 @@ export {
   u64,
   u8,
   u8aEq,
-  u8aToHex,
+  u8aToHex2 as u8aToHex,
   waitForLoad
 };
 //# sourceMappingURL=index.js.map