@argonprotocol/mainchain 1.3.11 → 1.3.13

package/lib/index.cjs

@@ -81,158 +81,6 @@ var WageProtector = class _WageProtector {
   }
 };
 
-// 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;
@@ -280,12 +128,13 @@ function dispatchErrorToString(client, error) {
   }
   return message;
 }
-var ExtrinsicError2 = class extends Error {
-  constructor(errorCode, details, batchInterruptedIndex) {
+var ExtrinsicError = class extends Error {
+  constructor(errorCode, details, batchInterruptedIndex, txFee = 0n) {
     super(errorCode);
     this.errorCode = errorCode;
     this.details = details;
     this.batchInterruptedIndex = batchInterruptedIndex;
+    this.txFee = txFee;
   }
   toString() {
     if (this.batchInterruptedIndex !== void 0) {
@@ -294,13 +143,13 @@ var ExtrinsicError2 = class extends Error {
     return `${this.errorCode} ${_nullishCoalesce(this.details, () => ( ""))}`;
   }
 };
-function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
+function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex, txFee) {
   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 ExtrinsicError(`${section}.${name}`, docs.join(" "), batchInterruptedIndex, txFee);
   }
-  return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
+  return new ExtrinsicError(error.toString(), void 0, batchInterruptedIndex, txFee);
 }
 function checkForExtrinsicSuccess(events, client) {
   return new Promise((resolve, reject) => {
@@ -320,6 +169,243 @@ function checkForExtrinsicSuccess(events, client) {
   });
 }
 
+// src/TxResult.ts
+var TxResult = (_class = class {
+  constructor(client, extrinsic) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.client = client;
+    this.extrinsic = extrinsic;
+    this.waitForFinalizedBlock = new Promise((resolve, reject) => {
+      this.finalizedResolve = resolve;
+      this.finalizedReject = reject;
+    });
+    this.waitForInFirstBlock = new Promise((resolve, reject) => {
+      this.inBlockResolve = resolve;
+      this.inBlockReject = reject;
+    });
+    this.waitForFinalizedBlock.catch(() => null);
+    this.waitForInFirstBlock.catch(() => null);
+  }
+  #isBroadcast = false;
+  #submissionError;
+  set isBroadcast(value) {
+    this.#isBroadcast = value;
+    this.updateProgress();
+  }
+  get isBroadcast() {
+    return this.#isBroadcast;
+  }
+  set submissionError(value) {
+    if (value) {
+      this.#submissionError = value;
+      this.finalizedReject(value);
+      this.inBlockReject(value);
+      this.updateProgress();
+    }
+  }
+  get submissionError() {
+    return this.#submissionError;
+  }
+  
+  
+  __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.
+   */
+  
+  __init2() {this.txProgress = 0}
+  __init3() {this.isFinalized = false}
+  
+  
+  
+  
+  async setSeenInBlock(block) {
+    const { blockHash, blockNumber, events } = block;
+    if (blockHash !== this.blockHash) {
+      this.parseEvents(events);
+      this.blockHash = blockHash;
+      this.blockNumber = await _asyncNullishCoalesce(blockNumber, async () => ( await this.client.rpc.chain.getHeader(blockHash).then((h) => h.number.toNumber())));
+      this.extrinsicIndex = block.extrinsicIndex;
+      this.updateProgress();
+      if (this.extrinsicError) {
+        this.inBlockReject(this.extrinsicError);
+      } else {
+        this.inBlockResolve(blockHash);
+      }
+    }
+  }
+  setFinalized() {
+    this.isFinalized = true;
+    this.updateProgress();
+    let error = _nullishCoalesce(this.extrinsicError, () => ( this.submissionError));
+    if (!error && !this.blockHash) {
+      error = new Error("Cannot finalize transaction before it is included in a block");
+    }
+    if (error) {
+      this.finalizedReject(error);
+      this.inBlockReject(error);
+    } else {
+      this.finalizedResolve(this.blockHash);
+      this.inBlockResolve(this.blockHash);
+    }
+  }
+  onSubscriptionResult(result) {
+    const { events, status, isFinalized, txIndex } = result;
+    const extrinsicEvents = events.map((x) => x.event);
+    if (status.isBroadcast) {
+      this.isBroadcast = true;
+      if (result.internalError) this.submissionError = result.internalError;
+    }
+    if (status.isInBlock) {
+      void this.setSeenInBlock({
+        blockHash: Uint8Array.from(status.asInBlock),
+        events: extrinsicEvents,
+        extrinsicIndex: txIndex
+      });
+    }
+    if (isFinalized) {
+      this.setFinalized();
+    }
+  }
+  updateProgress() {
+    if (this.isFinalized || this.submissionError) {
+      this.txProgress = 100;
+    } else if (this.blockNumber) {
+      const elapsedBlocks = this.blockNumber - this.extrinsic.submittedAtBlockNumber;
+      const FINALIZATION_BLOCKS = 5;
+      const remainingPercent = Math.max(0, FINALIZATION_BLOCKS - elapsedBlocks) * 20;
+      const percent = 100 - remainingPercent;
+      this.txProgress = Math.min(percent, 99);
+    } else if (this.extrinsic.submittedAtBlockNumber) {
+      this.txProgress = 10;
+    }
+    _optionalChain([this, 'access', _ => _.txProgressCallback, 'optionalCall', _2 => _2(this.txProgress)]);
+  }
+  parseEvents(events) {
+    let encounteredError;
+    for (const event of events) {
+      if (this.client.events.system.ExtrinsicFailed.is(event)) {
+        const { dispatchError } = event.data;
+        encounteredError ??= dispatchError;
+      }
+      if (this.client.events.utility.BatchInterrupted.is(event)) {
+        const { index, error } = event.data;
+        this.batchInterruptedIndex = index.toNumber();
+        encounteredError = error;
+      }
+      if (this.client.events.transactionPayment.TransactionFeePaid.is(event)) {
+        const { actualFee, tip } = event.data;
+        this.finalFee = actualFee.toBigInt();
+        this.finalFeeTip = tip.toBigInt();
+      }
+    }
+    if (encounteredError) {
+      this.extrinsicError = dispatchErrorToExtrinsicError(
+        this.client,
+        encounteredError,
+        this.batchInterruptedIndex,
+        this.finalFee
+      );
+    } else {
+      this.extrinsicError = void 0;
+    }
+    this.events = events;
+  }
+}, _class);
+
+// src/TxSubmitter.ts
+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 { useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
+    const blockHeight = await this.client.rpc.chain.getHeader().then((h) => h.number.toNumber());
+    if (options.logResults) {
+      this.logRequest();
+    }
+    if (useLatestNonce && !apiOptions.nonce) {
+      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
+    }
+    const signedTx = await this.tx.signAsync(this.pair, apiOptions);
+    const txHash = signedTx.hash.toHex();
+    const result = new TxResult(this.client, {
+      signedHash: txHash,
+      method: signedTx.method.toHuman(),
+      accountAddress: this.pair.address,
+      submittedTime: /* @__PURE__ */ new Date(),
+      submittedAtBlockNumber: blockHeight
+    });
+    if (options.disableAutomaticTxTracking !== true) {
+      await signedTx.send(result.onSubscriptionResult.bind(result));
+    } else {
+      try {
+        await signedTx.send();
+        result.isBroadcast = true;
+      } catch (error) {
+        result.submissionError = error;
+      }
+    }
+    return result;
+  }
+  logRequest() {
+    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("->"));
+    console.log("Submitting transaction from %s:", this.pair.address, ...args);
+  }
+};
+function formatCall(call) {
+  return `${call.section}.${call.method}`;
+}
+
 // src/keyringUtils.ts
 function keyringFromSuri(suri, cryptoType = "sr25519") {
   return new (0, _api.Keyring)({ type: cryptoType }).createFromUri(suri);
@@ -517,29 +603,29 @@ var Vault = class _Vault {
       );
     }
     const result = await tx.submit({
-      tip,
-      useLatestNonce: true,
-      waitForBlock: true,
-      txProgressCallback
+      ...args,
+      useLatestNonce: true
     });
-    await result.inBlockPromise;
-    let vaultId;
-    for (const event of result.events) {
-      if (client.events.vaults.VaultCreated.is(event)) {
-        vaultId = event.data.vaultId.toNumber();
-        break;
+    const tickDuration = await _asyncNullishCoalesce(config.tickDurationMillis, async () => ( await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber())));
+    async function getVault() {
+      await result.waitForFinalizedBlock;
+      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");
+      }
+      return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
     }
-    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 };
+    return { getVault, txResult: result };
   }
 };
 
@@ -629,7 +715,7 @@ var BitcoinLocks = class {
     };
   }
   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)));
+    return await this.client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _3 => _3.value, 'optionalAccess', _4 => _4.blockHeight, 'access', _5 => _5.toNumber, 'call', _6 => _6()]), () => ( 0)));
   }
   /**
    * Gets the UTXO reference by ID.
@@ -678,7 +764,7 @@ var BitcoinLocks = class {
     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 });
+    return await submitter.submit(args);
   }
   async getBitcoinLock(utxoId) {
     const utxoRaw = await this.client.query.bitcoinLocks.locksByUtxoId(utxoId);
@@ -757,7 +843,7 @@ var BitcoinLocks = class {
         const atHeight = header.number.toNumber();
         this.getVaultCosignSignature(utxoId, atHeight).then((signature) => {
           if (signature) {
-            _optionalChain([unsub, 'optionalCall', _5 => _5()]);
+            _optionalChain([unsub, 'optionalCall', _7 => _7()]);
             clearTimeout(timeout);
             resolve({ signature, blockHeight: atHeight });
           }
@@ -767,7 +853,7 @@ var BitcoinLocks = class {
       });
       if (waitForSignatureMillis !== -1) {
         timeout = setTimeout(() => {
-          _optionalChain([unsub, 'optionalCall', _6 => _6()]);
+          _optionalChain([unsub, 'optionalCall', _8 => _8()]);
           reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${utxoId}`));
         }, waitForSignatureMillis);
       }
@@ -844,17 +930,11 @@ var BitcoinLocks = class {
       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 };
+    return { tx, securityFee, txFee, canAfford, availableBalance, txFeePlusTip: txFee + tip };
   }
   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());
+    await txResult.waitForFinalizedBlock;
+    const blockHeight = txResult.blockNumber;
     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");
@@ -866,20 +946,18 @@ var BitcoinLocks = class {
     return { lock, createdAtHeight: blockHeight, txResult };
   }
   async initializeLock(args) {
-    const { argonKeyring, tip = 0n, txProgressCallback } = args;
+    const { argonKeyring } = args;
     const client = this.client;
-    const { tx, securityFee } = await this.createInitializeLockTx(args);
+    const { tx, securityFee, canAfford, txFeePlusTip } = await this.createInitializeLockTx(args);
+    if (!canAfford) {
+      throw new Error(
+        `Insufficient funds to initialize bitcoin lock. Required security fee: ${formatArgons(securityFee)}, Tx fee plus tip: ${formatArgons(txFeePlusTip)}`
+      );
+    }
     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);
+    const txResult = await submitter.submit({ logResults: true, ...args });
     return {
-      lock,
-      createdAtHeight,
+      getLock: () => this.getBitcoinLockFromTxResult(txResult),
       txResult,
       securityFee
     };
@@ -895,8 +973,7 @@ var BitcoinLocks = class {
       priceIndex,
       releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
       argonKeyring,
-      tip,
-      txProgressCallback
+      tip = 0n
     } = args;
     if (!toScriptPubkey.startsWith("0x")) {
       throw new Error("toScriptPubkey must be a hex string starting with 0x");
@@ -913,21 +990,13 @@ var BitcoinLocks = class {
     });
     if (!canAfford.canAfford) {
       throw new Error(
-        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice)}`
+        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice + canAfford.txFee + tip)}`
       );
     }
-    const txResult = await submitter.submit({
-      waitForBlock: true,
+    return submitter.submit({
       logResults: true,
-      tip,
-      txProgressCallback
+      ...args
     });
-    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);
@@ -974,41 +1043,43 @@ var BitcoinLocks = class {
         )}`
       );
     }
-    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();
-    }
+    const txResult = await txSubmitter.submit(args);
+    const getRatchetResult = async () => {
+      const blockHash = await txResult.waitForFinalizedBlock;
+      const ratchetEvent = txResult.events.find(
+        (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
+      );
+      if (!ratchetEvent) {
+        throw new Error(`Ratchet event not found in transaction events`);
+      }
+      const api = await client.at(blockHash);
+      const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
+      const {
+        amountBurned,
+        liquidityPromised: liquidityPromisedRaw,
+        newPeggedPrice,
+        originalPeggedPrice,
+        securityFee
+      } = ratchetEvent.data;
+      const liquidityPromised = liquidityPromisedRaw.toBigInt();
+      let mintAmount = liquidityPromised;
+      if (liquidityPromised > originalPeggedPrice.toBigInt()) {
+        mintAmount -= originalPeggedPrice.toBigInt();
+      }
+      return {
+        txFee: _nullishCoalesce(txResult.finalFee, () => ( 0n)),
+        blockHeight: txResult.blockNumber,
+        bitcoinBlockHeight,
+        pendingMint: mintAmount,
+        liquidityPromised,
+        newPeggedPrice: newPeggedPrice.toBigInt(),
+        burned: amountBurned.toBigInt(),
+        securityFee: securityFee.toBigInt()
+      };
+    };
     return {
-      txFee: _nullishCoalesce(submission.finalFee, () => ( 0n)),
-      securityFee: ratchetPrice.ratchetingFee,
-      pendingMint: mintAmount,
-      liquidityPromised,
-      newPeggedPrice: newPeggedPrice.toBigInt(),
-      burned: amountBurned.toBigInt(),
-      blockHeight,
-      bitcoinBlockHeight
+      txResult,
+      getRatchetResult
     };
   }
 };
@@ -1166,5 +1237,5 @@ async function getClient(host, options) {
 
 
 
-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.PriceIndex = PriceIndex; 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;
+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 = ExtrinsicError; 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.PriceIndex = PriceIndex; 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