@argonprotocol/mainchain 1.3.7 → 1.3.8

package/lib/index.cjs

@@ -1,6 +1,997 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"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 _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;// src/interfaces/augment-api-consts.ts
+require('@polkadot/api-base/types/consts');
+
+// src/interfaces/augment-api-errors.ts
+require('@polkadot/api-base/types/errors');
+
+// src/interfaces/augment-api-events.ts
+require('@polkadot/api-base/types/events');
+
+// src/interfaces/augment-api-query.ts
+require('@polkadot/api-base/types/storage');
+
+// src/interfaces/augment-api-tx.ts
+require('@polkadot/api-base/types/submittable');
+
+// src/interfaces/augment-api-rpc.ts
+require('@polkadot/rpc-core/types/jsonrpc');
+
+// src/interfaces/augment-api-runtime.ts
+require('@polkadot/api-base/types/calls');
+
+// src/interfaces/augment-types.ts
+require('@polkadot/types/types/registry');
+
+// src/index.ts
+var _api = require('@polkadot/api');
+var _utilcrypto = require('@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 + (_nullishCoalesce(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 = class {
+  constructor(client, shouldLog = false) {;_class.prototype.__init.call(this);
+    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);
+  }
+  
+  
+  
+  __init() {this.events = []}
+  /**
+   * The index of the batch that was interrupted, if any.
+   */
+  
+  
+  /**
+   * The final fee paid for the transaction, including the fee tip.
+   */
+  
+  /**
+   * The fee tip paid for the transaction.
+   */
+  
+  
+  
+  
+  
+  
+  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);
+  }
+}, _class);
+
+// src/utils.ts
+var _bignumberjs = require('bignumber.js'); var BN = _interopRequireWildcard(_bignumberjs); var BN2 = _interopRequireWildcard(_bignumberjs);
+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 = BN.default.call(void 0, microgons.toString()).abs().div(MICROGONS_PER_ARGON).toFormat(2, ROUND_FLOOR);
+  if (format.endsWith(".00")) {
+    format = format.slice(0, -3);
+  }
+  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} ${_nullishCoalesce(this.details, () => ( ""))} (Batch interrupted at index ${this.batchInterruptedIndex})`;
+    }
+    return `${this.errorCode} ${_nullishCoalesce(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 (0, _api.Keyring)({ type: cryptoType }).createFromUri(suri);
+}
+function createKeyringPair(opts) {
+  const { cryptoType } = opts;
+  const seed = _utilcrypto.mnemonicGenerate.call(void 0, );
+  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
+
+var _bs58check = require('bs58check'); var _bs58check2 = _interopRequireDefault(_bs58check);
+var _util = require('@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);
+  }
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  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(),
+      liquidityPoolProfitSharing: fromFixedNumber(
+        vault.terms.liquidityPoolProfitSharing.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(),
+        liquidityPoolProfitSharing: fromFixedNumber(
+          vault.terms.liquidityPoolProfitSharing.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 (0, BN.default)(this.securitizationRatio);
+  }
+  recoverySecuritization() {
+    const reserved = new (0, BN.default)(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, BN.default.ROUND_CEIL).toString()
+    );
+  }
+  activatedSecuritization() {
+    const activated = this.argonsLocked - this.argonsPendingActivation;
+    const maxRatio = BN.default.call(void 0, Math.min(this.securitizationRatio, 2));
+    return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
+  }
+  /**
+   * Returns the amount of Argons available to match per liquidity pool
+   */
+  activatedSecuritizationPerSlot() {
+    const activated = this.activatedSecuritization();
+    return activated / 10n;
+  }
+  calculateBitcoinFee(amount) {
+    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, tickDurationMillis) {
+    const rawVault = await client.query.vaults.vaultsById(vaultId);
+    if (rawVault.isNone) {
+      throw new Error(`Vault with id ${vaultId} not found`);
+    }
+    const tickDuration = await _asyncNullishCoalesce(tickDurationMillis, async () => ( 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 = _util.hexToU8a.call(void 0, bitcoinXpub);
+    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 = bytes;
+      }
+    }
+    const vaultParams = {
+      terms: {
+        // convert to fixed u128
+        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, FIXED_U128_DECIMALS),
+        bitcoinBaseFee: BigInt(baseFee),
+        liquidityPoolProfitSharing: toFixedNumber(
+          args.liquidityPoolProfitSharing,
+          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 = _nullishCoalesce(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 = await _asyncNullishCoalesce(config.tickDurationMillis, async () => ( 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
+
+function toFixedNumber(value, decimals) {
+  const factor = new (0, BN.default)(10).pow(decimals);
+  const bn = new (0, BN.default)(value);
+  const int = bn.times(factor).integerValue(BN.default.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
+}
+function fromFixedNumber(value, decimals = FIXED_U128_DECIMALS) {
+  const factor = new (0, BN.default)(10).pow(decimals);
+  const bn = new (0, BN.default)(value.toString());
+  return bn.div(factor);
+}
+var FIXED_U128_DECIMALS = 18;
+var PERMILL_DECIMALS = 6;
+
+// src/BitcoinLocks.ts
+
+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(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 getRedemptionRate(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) => _nullishCoalesce(_optionalChain([x, 'access', _ => _.value, 'optionalAccess', _2 => _2.blockHeight, 'access', _3 => _3.toNumber, 'call', _4 => _4()]), () => ( 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 = _nullishCoalesce(clientAtHeight, () => ( this.client));
+    const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
+    if (!refRaw) {
+      return;
+    }
+    const ref = refRaw.unwrap();
+    const txid = _util.u8aToHex.call(void 0, ref.txid);
+    const bitcoinTxid = _util.u8aToHex.call(void 0, ref.txid.reverse());
+    const vout = ref.outputIndex.toNumber();
+    return { txid, vout, bitcoinTxid };
+  }
+  async getReleaseRequest(utxoId, clientAtHeight) {
+    const client = _nullishCoalesce(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 = _util.u8aToHex.call(void 0, 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 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,
+      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) {
+            _optionalChain([unsub, 'optionalCall', _5 => _5()]);
+            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', _6 => _6()]);
+          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, 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(BigInt(satoshis));
+    const isVaultOwner = argonKeyring.address === vault.operatorAccountId;
+    const securityFee = isVaultOwner ? 0n : vault.calculateBitcoinFee(marketPrice);
+    const { canAfford, availableBalance, txFee } = await submitter.canAfford({
+      tip,
+      unavailableBalance: securityFee + (_nullishCoalesce(args.reducedBalanceBy, () => ( 0n))),
+      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 _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 };
+  }
+  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(argonAmount) {
+    const marketRatePerBitcoin = await this.getMarketRate(SATS_PER_BTC);
+    return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
+  }
+  async requestRelease(args) {
+    const client = this.client;
+    const {
+      lock,
+      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
+    );
+    let redemptionPrice = await this.getRedemptionRate(lock.satoshis);
+    if (redemptionPrice > lock.peggedPrice) {
+      redemptionPrice = lock.peggedPrice;
+    }
+    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(satoshis, peggedPrice) {
+    const redemptionRate = await this.getRedemptionRate(satoshis);
+    if (redemptionRate > peggedPrice) {
+      return redemptionRate;
+    }
+    return peggedPrice;
+  }
+  async getRatchetPrice(lock, vault) {
+    const { createdAtHeight, vaultClaimHeight, peggedPrice, satoshis } = lock;
+    const client = this.client;
+    const marketRate = await this.getMarketRate(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(lock.satoshis, peggedPrice);
+    }
+    return {
+      ratchetingFee,
+      burnAmount,
+      marketRate
+    };
+  }
+  async ratchet(args) {
+    const { lock, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
+    const client = 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,
+      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, newPeggedPrice, originalPeggedPrice } = ratchetEvent.data;
+    let mintAmount = newPeggedPrice.toBigInt();
+    if (newPeggedPrice > originalPeggedPrice) {
+      mintAmount -= originalPeggedPrice.toBigInt();
+    }
+    return {
+      txFee: _nullishCoalesce(submission.finalFee, () => ( 0n)),
+      securityFee: ratchetPrice.ratchetingFee,
+      pendingMint: mintAmount,
+      newPeggedPrice: newPeggedPrice.toBigInt(),
+      burned: amountBurned.toBigInt(),
+      blockHeight,
+      bitcoinBlockHeight
+    };
+  }
+};
 
+// src/index.ts
 
+var _generic = require('@polkadot/types/generic');
 
 
 
@@ -24,6 +1015,19 @@
 
 
 
+var _typescodec = require('@polkadot/types-codec');
+async function waitForLoad() {
+  await _utilcrypto.cryptoWaitReady.call(void 0, );
+}
+async function getClient(host, options) {
+  let provider;
+  if (host.startsWith("http")) {
+    provider = new (0, _api.HttpProvider)(host);
+  } else {
+    provider = new (0, _api.WsProvider)(host);
+  }
+  return await _api.ApiPromise.create({ provider, noInitWarn: true, ..._nullishCoalesce(options, () => ( {})) });
+}
 
 
 
@@ -72,7 +1076,6 @@
 
 
 
-var _chunkVXYWJG66cjs = require('./chunk-VXYWJG66.cjs');
 
 
 
@@ -80,72 +1083,5 @@ var _chunkVXYWJG66cjs = require('./chunk-VXYWJG66.cjs');
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.AccountMiners = _chunkVXYWJG66cjs.AccountMiners; exports.AccountRegistry = _chunkVXYWJG66cjs.AccountRegistry; exports.Accountset = _chunkVXYWJG66cjs.Accountset; exports.BTreeMap = _chunkVXYWJG66cjs.BTreeMap; exports.BidPool = _chunkVXYWJG66cjs.BidPool; exports.BitcoinLocks = _chunkVXYWJG66cjs.BitcoinLocks; exports.BlockWatch = _chunkVXYWJG66cjs.BlockWatch; exports.Bool = _chunkVXYWJG66cjs.Bool; exports.Bytes = _chunkVXYWJG66cjs.Bytes; exports.CohortBidder = _chunkVXYWJG66cjs.CohortBidder; exports.Compact = _chunkVXYWJG66cjs.Compact; exports.Enum = _chunkVXYWJG66cjs.Enum; exports.ExtrinsicError = _chunkVXYWJG66cjs.ExtrinsicError; exports.FrameCalculator = _chunkVXYWJG66cjs.FrameCalculator; exports.GenericAddress = _chunkVXYWJG66cjs.GenericAddress; exports.GenericBlock = _chunkVXYWJG66cjs.GenericBlock; exports.GenericEvent = _chunkVXYWJG66cjs.GenericEvent; exports.JsonExt = _chunkVXYWJG66cjs.JsonExt; exports.Keyring = _chunkVXYWJG66cjs.Keyring; exports.MICROGONS_PER_ARGON = _chunkVXYWJG66cjs.MICROGONS_PER_ARGON; exports.MiningBids = _chunkVXYWJG66cjs.MiningBids; exports.Null = _chunkVXYWJG66cjs.Null; exports.Option = _chunkVXYWJG66cjs.Option; exports.Range = _chunkVXYWJG66cjs.Range; exports.Result = _chunkVXYWJG66cjs.Result; exports.SATS_PER_BTC = _chunkVXYWJG66cjs.SATS_PER_BTC; exports.Struct = _chunkVXYWJG66cjs.Struct; exports.Text = _chunkVXYWJG66cjs.Text; exports.Tuple = _chunkVXYWJG66cjs.Tuple; exports.TxResult = _chunkVXYWJG66cjs.TxResult; exports.TxSubmitter = _chunkVXYWJG66cjs.TxSubmitter; exports.TypedEmitter = _chunkVXYWJG66cjs.TypedEmitter; exports.U256 = _chunkVXYWJG66cjs.U256; exports.U8aFixed = _chunkVXYWJG66cjs.U8aFixed; exports.Vault = _chunkVXYWJG66cjs.Vault; exports.VaultMonitor = _chunkVXYWJG66cjs.VaultMonitor; exports.Vec = _chunkVXYWJG66cjs.Vec; exports.WageProtector = _chunkVXYWJG66cjs.WageProtector; exports.bool = _chunkVXYWJG66cjs.bool; exports.checkForExtrinsicSuccess = _chunkVXYWJG66cjs.checkForExtrinsicSuccess; exports.convertFixedU128ToBigNumber = _chunkVXYWJG66cjs.convertFixedU128ToBigNumber; exports.convertNumberToFixedU128 = _chunkVXYWJG66cjs.convertNumberToFixedU128; exports.convertNumberToPermill = _chunkVXYWJG66cjs.convertNumberToPermill; exports.convertPermillToBigNumber = _chunkVXYWJG66cjs.convertPermillToBigNumber; exports.createKeyringPair = _chunkVXYWJG66cjs.createKeyringPair; exports.createNanoEvents = _chunkVXYWJG66cjs.createNanoEvents; exports.decodeAddress = _chunkVXYWJG66cjs.decodeAddress; exports.dispatchErrorToExtrinsicError = _chunkVXYWJG66cjs.dispatchErrorToExtrinsicError; exports.dispatchErrorToString = _chunkVXYWJG66cjs.dispatchErrorToString; exports.eventDataToJson = _chunkVXYWJG66cjs.eventDataToJson; exports.filterUndefined = _chunkVXYWJG66cjs.filterUndefined; exports.formatArgons = _chunkVXYWJG66cjs.formatArgons; exports.formatPercent = _chunkVXYWJG66cjs.formatPercent; exports.getAuthorFromHeader = _chunkVXYWJG66cjs.getAuthorFromHeader; exports.getClient = _chunkVXYWJG66cjs.getClient; exports.getConfig = _chunkVXYWJG66cjs.getConfig; exports.getTickFromHeader = _chunkVXYWJG66cjs.getTickFromHeader; exports.gettersToObject = _chunkVXYWJG66cjs.gettersToObject; exports.hexToU8a = _chunkVXYWJG66cjs.hexToU8a; exports.i128 = _chunkVXYWJG66cjs.i128; exports.keyringFromSuri = _chunkVXYWJG66cjs.keyringFromSuri; exports.miniSecretFromUri = _chunkVXYWJG66cjs.miniSecretFromUri; exports.mnemonicGenerate = _chunkVXYWJG66cjs.mnemonicGenerate; exports.setConfig = _chunkVXYWJG66cjs.setConfig; exports.toFixedNumber = _chunkVXYWJG66cjs.toFixedNumber; exports.u128 = _chunkVXYWJG66cjs.u128; exports.u16 = _chunkVXYWJG66cjs.u16; exports.u32 = _chunkVXYWJG66cjs.u32; exports.u64 = _chunkVXYWJG66cjs.u64; exports.u8 = _chunkVXYWJG66cjs.u8; exports.u8aEq = _chunkVXYWJG66cjs.u8aEq; exports.u8aToHex = _chunkVXYWJG66cjs.u8aToHex; exports.waitForLoad = _chunkVXYWJG66cjs.waitForLoad;
+exports.BTreeMap = _typescodec.BTreeMap; exports.BitcoinLocks = BitcoinLocks; exports.Bool = _typescodec.Bool; exports.Bytes = _typescodec.Bytes; exports.Compact = _typescodec.Compact; exports.Enum = _typescodec.Enum; exports.ExtrinsicError = ExtrinsicError2; exports.FIXED_U128_DECIMALS = FIXED_U128_DECIMALS; exports.GenericAddress = _generic.GenericAddress; exports.GenericBlock = _generic.GenericBlock; exports.GenericEvent = _generic.GenericEvent; exports.Keyring = _api.Keyring; exports.MICROGONS_PER_ARGON = MICROGONS_PER_ARGON; exports.Null = _typescodec.Null; exports.Option = _typescodec.Option; exports.PERMILL_DECIMALS = PERMILL_DECIMALS; exports.Range = _typescodec.Range; exports.Result = _typescodec.Result; exports.SATS_PER_BTC = SATS_PER_BTC; exports.Struct = _typescodec.Struct; exports.Text = _typescodec.Text; exports.Tuple = _typescodec.Tuple; exports.TxResult = TxResult; exports.TxSubmitter = TxSubmitter; exports.U256 = _typescodec.U256; exports.U8aFixed = _typescodec.U8aFixed; exports.Vault = Vault; exports.Vec = _typescodec.Vec; exports.WageProtector = WageProtector; exports.bool = _typescodec.bool; exports.checkForExtrinsicSuccess = checkForExtrinsicSuccess; exports.createKeyringPair = createKeyringPair; exports.decodeAddress = _utilcrypto.decodeAddress; exports.dispatchErrorToExtrinsicError = dispatchErrorToExtrinsicError; exports.dispatchErrorToString = dispatchErrorToString; exports.formatArgons = formatArgons; exports.fromFixedNumber = fromFixedNumber; exports.getAuthorFromHeader = getAuthorFromHeader; exports.getClient = getClient; exports.getTickFromHeader = getTickFromHeader; exports.gettersToObject = gettersToObject; exports.hexToU8a = _util.hexToU8a; exports.i128 = _typescodec.i128; exports.keyringFromSuri = keyringFromSuri; exports.mnemonicGenerate = _utilcrypto.mnemonicGenerate; exports.toFixedNumber = toFixedNumber; exports.u128 = _typescodec.u128; exports.u16 = _typescodec.u16; exports.u32 = _typescodec.u32; exports.u64 = _typescodec.u64; exports.u8 = _typescodec.u8; exports.u8aEq = _util.u8aEq; exports.u8aToHex = _util.u8aToHex; exports.waitForLoad = waitForLoad;
 //# sourceMappingURL=index.cjs.map