@argonprotocol/mainchain 1.4.9-dev.8f82736f → 1.4.9-dev.c17ec6c5

package/lib/index.cjs

@@ -220,6 +220,7 @@ var TxResult = (_class = class {
   }
   #isBroadcast = false;
   #submissionError;
+  #pendingInBlock;
   set isBroadcast(value) {
     this.#isBroadcast = value;
     this.updateProgress();
@@ -265,21 +266,44 @@ var TxResult = (_class = class {
   
   
   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);
-      }
+    if (block.blockNumber === void 0) {
+      this.#pendingInBlock = {
+        blockHash: block.blockHash,
+        extrinsicIndex: block.extrinsicIndex,
+        events: block.events
+      };
+      return;
+    }
+    if (this.blockHash && this.blockNumber === block.blockNumber && this.extrinsicIndex === block.extrinsicIndex && _util.u8aEq.call(void 0, this.blockHash, block.blockHash)) {
+      this.#pendingInBlock = void 0;
+      return;
+    }
+    this.#pendingInBlock = void 0;
+    this.parseEvents(block.events);
+    this.blockHash = block.blockHash;
+    this.blockNumber = block.blockNumber;
+    this.extrinsicIndex = block.extrinsicIndex;
+    this.updateProgress();
+    if (this.extrinsicError) {
+      this.inBlockReject(this.extrinsicError);
+    } else {
+      this.inBlockResolve(block.blockHash);
     }
   }
-  setFinalized() {
+  async setFinalized() {
+    const pendingInBlock = this.#pendingInBlock;
+    if (pendingInBlock) {
+      await this.publishSeenInBlock(pendingInBlock);
+    } else if (this.blockHash && this.blockNumber === void 0) {
+      if (this.extrinsicIndex === void 0) {
+        throw new Error("Cannot finalize transaction before extrinsic index is known");
+      }
+      await this.publishSeenInBlock({
+        blockHash: this.blockHash,
+        extrinsicIndex: this.extrinsicIndex,
+        events: this.events
+      });
+    }
     this.isFinalized = true;
     this.updateProgress();
     let error = _nullishCoalesce(this.extrinsicError, () => ( this.submissionError));
@@ -302,33 +326,73 @@ var TxResult = (_class = class {
       if (result2.internalError) this.submissionError = result2.internalError;
     }
     if (status.isInBlock) {
-      void this.setSeenInBlock({
-        blockHash: Uint8Array.from(status.asInBlock),
-        events: extrinsicEvents,
-        extrinsicIndex: txIndex
-      });
+      try {
+        const pendingInBlock = createPendingInBlock(
+          Uint8Array.from(status.asInBlock),
+          txIndex,
+          extrinsicEvents
+        );
+        this.#pendingInBlock = pendingInBlock;
+        void this.publishSeenInBlock(pendingInBlock).catch((error) => {
+          if (!isMissingBlockHeaderError(error)) {
+            this.submissionError = error;
+          }
+        });
+      } catch (error) {
+        this.submissionError = error;
+      }
     }
     if (status.isUsurped) {
+      this.#pendingInBlock = void 0;
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Usurped,
         `Transaction was usurped by ${status.asUsurped.toHex()}.`
       );
     }
     if (status.isDropped) {
+      this.#pendingInBlock = void 0;
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Dropped,
         "Transaction was dropped before it was included in a block."
       );
     }
     if (status.isInvalid) {
+      this.#pendingInBlock = void 0;
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Invalid,
         "Transaction was rejected as invalid by the node."
       );
     }
     if (isFinalized) {
-      this.setFinalized();
+      try {
+        this.#pendingInBlock = createPendingInBlock(
+          Uint8Array.from(status.asFinalized),
+          _nullishCoalesce(_nullishCoalesce(txIndex, () => ( _optionalChain([this, 'access', _ => _.#pendingInBlock, 'optionalAccess', _2 => _2.extrinsicIndex]))), () => ( this.extrinsicIndex)),
+          extrinsicEvents.length ? extrinsicEvents : this.events
+        );
+      } catch (error) {
+        this.submissionError = error;
+        return;
+      }
+      void this.setFinalized().catch((error) => {
+        this.submissionError = error;
+      });
+    }
+  }
+  async publishSeenInBlock(block) {
+    const pendingInBlock = this.#pendingInBlock;
+    if (!pendingInBlock || pendingInBlock.extrinsicIndex !== block.extrinsicIndex || !_util.u8aEq.call(void 0, pendingInBlock.blockHash, block.blockHash)) {
+      return;
     }
+    const blockNumber = await this.client.rpc.chain.getHeader(block.blockHash).then((h) => h.number.toNumber());
+    const currentPendingInBlock = this.#pendingInBlock;
+    if (!currentPendingInBlock || currentPendingInBlock.extrinsicIndex !== block.extrinsicIndex || !_util.u8aEq.call(void 0, currentPendingInBlock.blockHash, block.blockHash)) {
+      return;
+    }
+    await this.setSeenInBlock({
+      ...block,
+      blockNumber
+    });
   }
   updateProgress() {
     if (this.isFinalized || this.submissionError) {
@@ -342,7 +406,7 @@ var TxResult = (_class = class {
     } else if (this.extrinsic.submittedAtBlockNumber) {
       this.txProgress = 10;
     }
-    _optionalChain([this, 'access', _ => _.txProgressCallback, 'optionalCall', _2 => _2(this.txProgress)]);
+    _optionalChain([this, 'access', _3 => _3.txProgressCallback, 'optionalCall', _4 => _4(this.txProgress)]);
   }
   parseEvents(events) {
     let encounteredError;
@@ -375,6 +439,19 @@ var TxResult = (_class = class {
     this.events = events;
   }
 }, _class);
+function createPendingInBlock(blockHash, extrinsicIndex, events) {
+  if (extrinsicIndex === void 0) {
+    throw new Error("Cannot publish transaction block state before extrinsic index is known");
+  }
+  return {
+    blockHash,
+    extrinsicIndex,
+    events
+  };
+}
+function isMissingBlockHeaderError(error) {
+  return String(error).includes("Unable to retrieve header and parent from supplied hash");
+}
 
 // src/TxSubmitter.ts
 var TxSubmitter = class {
@@ -591,7 +668,7 @@ var Vault = class _Vault {
         PERMILL_DECIMALS
       ),
       treasuryBonusProfitSharing: fromFixedNumber(
-        _nullishCoalesce(_optionalChain([currentBonusSharingPercent, 'optionalAccess', _3 => _3.toBigInt, 'call', _4 => _4()]), () => ( 0n)),
+        _nullishCoalesce(_optionalChain([currentBonusSharingPercent, 'optionalAccess', _5 => _5.toBigInt, 'call', _6 => _6()]), () => ( 0n)),
         PERMILL_DECIMALS
       )
     };
@@ -624,7 +701,7 @@ var Vault = class _Vault {
           PERMILL_DECIMALS
         ),
         treasuryBonusProfitSharing: fromFixedNumber(
-          _nullishCoalesce(_optionalChain([pendingBonusSharingPercent, 'optionalAccess', _5 => _5.toBigInt, 'call', _6 => _6()]), () => ( 0n)),
+          _nullishCoalesce(_optionalChain([pendingBonusSharingPercent, 'optionalAccess', _7 => _7.toBigInt, 'call', _8 => _8()]), () => ( 0n)),
           PERMILL_DECIMALS
         )
       };
@@ -636,7 +713,7 @@ var Vault = class _Vault {
       this.lastNameChangeTick = vault.lastNameChangeTick.unwrap().toNumber();
     }
     const legacyDelegateAccount = vault.bitcoinLockDelegateAccount;
-    if (_optionalChain([legacyDelegateAccount, 'optionalAccess', _7 => _7.isSome])) {
+    if (_optionalChain([legacyDelegateAccount, 'optionalAccess', _9 => _9.isSome])) {
       this.delegateAccountId = legacyDelegateAccount.unwrap().toHuman();
     }
     if ("delegateAccountId" in vault && vault.delegateAccountId.isSome) {
@@ -1091,7 +1168,7 @@ var BitcoinLock = class _BitcoinLock {
         const atHeight = header.number.toNumber();
         this.getVaultCosignSignature(client, atHeight).then((signature) => {
           if (signature) {
-            _optionalChain([unsub, 'optionalCall', _8 => _8()]);
+            _optionalChain([unsub, 'optionalCall', _10 => _10()]);
             clearTimeout(timeout);
             resolve({ signature, blockHeight: atHeight });
           }
@@ -1101,7 +1178,7 @@ var BitcoinLock = class _BitcoinLock {
       });
       if (waitForSignatureMillis !== -1) {
         timeout = setTimeout(() => {
-          _optionalChain([unsub, 'optionalCall', _9 => _9()]);
+          _optionalChain([unsub, 'optionalCall', _11 => _11()]);
           reject(new Error(`Timeout waiting for cosign signature for UTXO ID ${this.utxoId}`));
         }, waitForSignatureMillis);
       }
@@ -1165,11 +1242,11 @@ var BitcoinLock = class _BitcoinLock {
       pendingConfirmationExpirationBlocks: client.consts.bitcoinUtxos.maxPendingConfirmationBlocks.toNumber(),
       tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
       bitcoinNetwork,
-      lockSatoshiAllowedVariance: _nullishCoalesce(_optionalChain([client, 'access', _10 => _10.consts, 'access', _11 => _11.bitcoinUtxos, 'access', _12 => _12.maximumSatoshiThresholdFromExpected, 'optionalAccess', _13 => _13.toNumber, 'call', _14 => _14()]), () => ( 1e4))
+      lockSatoshiAllowedVariance: _nullishCoalesce(_optionalChain([client, 'access', _12 => _12.consts, 'access', _13 => _13.bitcoinUtxos, 'access', _14 => _14.maximumSatoshiThresholdFromExpected, 'optionalAccess', _15 => _15.toNumber, 'call', _16 => _16()]), () => ( 1e4))
     };
   }
   static async getBitcoinConfirmedBlockHeight(client) {
-    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _15 => _15.value, 'optionalAccess', _16 => _16.blockHeight, 'access', _17 => _17.toNumber, 'call', _18 => _18()]), () => ( 0)));
+    return await client.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => _nullishCoalesce(_optionalChain([x, 'access', _17 => _17.value, 'optionalAccess', _18 => _18.blockHeight, 'access', _19 => _19.toNumber, 'call', _20 => _20()]), () => ( 0)));
   }
   static async submitVaultSignature(args) {
     const { utxoId, vaultSignature, txSigner, client } = args;
@@ -1186,15 +1263,15 @@ var BitcoinLock = class _BitcoinLock {
   static async createIncreaseSecuritizationTx(args) {
     const { client, newSatoshis, utxoId } = args;
     const txBuilder = client.tx.bitcoinLocks.increaseSecuritization;
-    if (!_optionalChain([txBuilder, 'optionalAccess', _19 => _19.meta])) {
+    if (!_optionalChain([txBuilder, 'optionalAccess', _21 => _21.meta])) {
       return void 0;
     }
     return txBuilder(utxoId, newSatoshis);
   }
   static async createFundWithUtxoCandidateTx(args) {
     const { client, utxoId, utxoRef } = args;
-    const txBuilder = _optionalChain([client, 'access', _20 => _20.tx, 'access', _21 => _21.bitcoinUtxos, 'optionalAccess', _22 => _22.fundWithUtxoCandidate]);
-    if (!_optionalChain([txBuilder, 'optionalAccess', _23 => _23.meta])) {
+    const txBuilder = _optionalChain([client, 'access', _22 => _22.tx, 'access', _23 => _23.bitcoinUtxos, 'optionalAccess', _24 => _24.fundWithUtxoCandidate]);
+    if (!_optionalChain([txBuilder, 'optionalAccess', _25 => _25.meta])) {
       return void 0;
     }
     return txBuilder(utxoId, normalizeUtxoRef(utxoRef));
@@ -1209,7 +1286,7 @@ var BitcoinLock = class _BitcoinLock {
       throw new Error("toScriptPubkey must be a hex string starting with 0x");
     }
     const txBuilder = client.tx.bitcoinLocks.requestOrphanedUtxoRelease;
-    if (!_optionalChain([txBuilder, 'optionalAccess', _24 => _24.meta])) {
+    if (!_optionalChain([txBuilder, 'optionalAccess', _26 => _26.meta])) {
       return void 0;
     }
     return txBuilder(normalizeUtxoRef(utxoRef), toScriptPubkey, bitcoinNetworkFee);
@@ -1221,7 +1298,7 @@ var BitcoinLock = class _BitcoinLock {
         `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
       );
     }
-    if (!_optionalChain([client, 'access', _25 => _25.tx, 'access', _26 => _26.bitcoinLocks, 'access', _27 => _27.cosignOrphanedUtxoRelease, 'optionalAccess', _28 => _28.meta])) {
+    if (!_optionalChain([client, 'access', _27 => _27.tx, 'access', _28 => _28.bitcoinLocks, 'access', _29 => _29.cosignOrphanedUtxoRelease, 'optionalAccess', _30 => _30.meta])) {
       return void 0;
     }
     const signature = _util.u8aToHex.call(void 0, vaultSignature);
@@ -1248,7 +1325,7 @@ var BitcoinLock = class _BitcoinLock {
     const liquidityPromised = utxo.liquidityPromised.toBigInt();
     const ownerAccount = utxo.ownerAccount.toHuman();
     const satoshis = utxo.satoshis.toBigInt();
-    const utxoSatoshis = _optionalChain([utxo, 'access', _29 => _29.utxoSatoshis, 'optionalAccess', _30 => _30.isSome]) ? utxo.utxoSatoshis.value.toBigInt() : void 0;
+    const utxoSatoshis = _optionalChain([utxo, 'access', _31 => _31.utxoSatoshis, 'optionalAccess', _32 => _32.isSome]) ? utxo.utxoSatoshis.value.toBigInt() : void 0;
     const vaultPubkey = utxo.vaultPubkey.toHex();
     const vaultClaimPubkey = utxo.vaultClaimPubkey.toHex();
     const ownerPubkey = utxo.ownerPubkey.toHex();
@@ -1258,16 +1335,16 @@ var BitcoinLock = class _BitcoinLock {
       cosignHdIndex: cosign_hd_index.toNumber(),
       claimHdIndex: claim_hd_index.toNumber()
     };
-    const createdAtArgonBlock = _nullishCoalesce(_optionalChain([utxo, 'access', _31 => _31.createdAtArgonBlock, 'optionalAccess', _32 => _32.toNumber, 'call', _33 => _33()]), () => ( 0));
+    const createdAtArgonBlock = _nullishCoalesce(_optionalChain([utxo, 'access', _33 => _33.createdAtArgonBlock, 'optionalAccess', _34 => _34.toNumber, 'call', _35 => _35()]), () => ( 0));
     const securityFees = utxo.securityFees.toBigInt();
     const vaultClaimHeight = utxo.vaultClaimHeight.toNumber();
     const openClaimHeight = utxo.openClaimHeight.toNumber();
     const createdAtHeight = utxo.createdAtHeight.toNumber();
-    const isFunded = (_nullishCoalesce(_optionalChain([utxo, 'optionalAccess', _34 => _34.isVerified]), () => ( utxo.isFunded))).toJSON();
+    const isFunded = (_nullishCoalesce(_optionalChain([utxo, 'optionalAccess', _36 => _36.isVerified]), () => ( utxo.isFunded))).toJSON();
     const fundHoldExtensionsByBitcoinExpirationHeight = Object.fromEntries(
       [...utxo.fundHoldExtensions.entries()].map(([x, y]) => [x.toNumber(), y.toBigInt()])
     );
-    const couponFeesPaid = _nullishCoalesce(_optionalChain([utxo, 'access', _35 => _35.couponPaidFees, 'optionalAccess', _36 => _36.toBigInt, 'call', _37 => _37()]), () => ( 0n));
+    const couponFeesPaid = _nullishCoalesce(_optionalChain([utxo, 'access', _37 => _37.couponPaidFees, 'optionalAccess', _38 => _38.toBigInt, 'call', _39 => _39()]), () => ( 0n));
     return new _BitcoinLock({
       utxoId,
       p2wshScriptHashHex,
@@ -7499,7 +7576,7 @@ var gatewayActivityEvents = [
 function findEthereumTransferToArgonStartedLogIndexes(receipt, gatewayAddress) {
   const normalizedGatewayAddress = _viem.getAddress.call(void 0, gatewayAddress).toLowerCase();
   const indexes = receipt.logs.flatMap(
-    (log, index) => log.address.toLowerCase() === normalizedGatewayAddress && _optionalChain([log, 'access', _38 => _38.topics, 'access', _39 => _39[0], 'optionalAccess', _40 => _40.toLowerCase, 'call', _41 => _41()]) === MintingGatewayEvents.TransferToArgonStarted.topic ? [index] : []
+    (log, index) => log.address.toLowerCase() === normalizedGatewayAddress && _optionalChain([log, 'access', _40 => _40.topics, 'access', _41 => _41[0], 'optionalAccess', _42 => _42.toLowerCase, 'call', _43 => _43()]) === MintingGatewayEvents.TransferToArgonStarted.topic ? [index] : []
   );
   if (indexes.length === 0) {
     throw new Error(
@@ -7519,7 +7596,7 @@ function decodeEthereumTransferToArgonStartedLog(log) {
   return transfer;
 }
 function decodeEthereumGatewayActivityLog(log) {
-  const topic = _optionalChain([log, 'access', _42 => _42.topics, 'access', _43 => _43[0], 'optionalAccess', _44 => _44.toLowerCase, 'call', _45 => _45()]);
+  const topic = _optionalChain([log, 'access', _44 => _44.topics, 'access', _45 => _45[0], 'optionalAccess', _46 => _46.toLowerCase, 'call', _47 => _47()]);
   if (!topic) {
     throw new Error("Gateway activity log is missing an event signature topic");
   }
@@ -7890,8 +7967,8 @@ async function loadRetainedExecutionHeaderAnchorAtOrAfterBlock(client, earliestB
     args: [],
     pageSize: 1,
     startKey: executionHeaderAnchorsByBlockNumber.key(scanBlockNumberKey)
-  })), 'access', async _46 => _46[0], 'optionalAccess', async _47 => _47[1]]);
-  const scannedAnchor = _optionalChain([matchingEntry, 'optionalAccess', _48 => _48.isSome]) ? matchingEntry.unwrap() : null;
+  })), 'access', async _48 => _48[0], 'optionalAccess', async _49 => _49[1]]);
+  const scannedAnchor = _optionalChain([matchingEntry, 'optionalAccess', _50 => _50.isSome]) ? matchingEntry.unwrap() : null;
   if (!scannedAnchor) {
     return null;
   }
@@ -7917,9 +7994,9 @@ async function collectProofChunksForArgonFinalizedExecutionHeader(executionClien
     if (blockNumber > plan.argonFinalizedExecutionHeader.blockNumber) {
       break;
     }
-    let targetHeader = _optionalChain([loadedTargetHeaders, 'access', _49 => _49.find, 'call', _50 => _50(
+    let targetHeader = _optionalChain([loadedTargetHeaders, 'access', _51 => _51.find, 'call', _52 => _52(
       (loadedHeader) => loadedHeader.blockHash.toLowerCase() === blockHash.toLowerCase()
-    ), 'optionalAccess', _51 => _51.targetHeader]);
+    ), 'optionalAccess', _53 => _53.targetHeader]);
     if (!targetHeader) {
       targetHeader = await loadExecutionHeader(executionClient, blockHash);
       loadedTargetHeaders.push({ blockHash, targetHeader });
@@ -7992,7 +8069,7 @@ function buildExecutionPayloadHeader(header) {
 
 // src/EthereumGatewayBackfill.ts
 async function buildGatewayExecutionHeaderBackfill(client, options) {
-  const targetExecutionBlockNumber = await _asyncNullishCoalesce(options.targetExecutionBlockNumber, async () => ( await _asyncOptionalChain([(await discoverGatewayActivities(client, options)), 'optionalAccess', async _52 => _52.activities, 'access', async _53 => _53[0], 'optionalAccess', async _54 => _54.blockNumber])));
+  const targetExecutionBlockNumber = await _asyncNullishCoalesce(options.targetExecutionBlockNumber, async () => ( await _asyncOptionalChain([(await discoverGatewayActivities(client, options)), 'optionalAccess', async _54 => _54.activities, 'access', async _55 => _55[0], 'optionalAccess', async _56 => _56.blockNumber])));
   if (targetExecutionBlockNumber == null) {
     return null;
   }
@@ -8261,7 +8338,7 @@ async function getNextEthereumBeaconSyncTxs(client, beaconApiUrl) {
         await new Promise((resolve) => setTimeout(resolve, lightClientUpdateRetryIntervalMs));
         continue;
       }
-      const periodUpdate = _optionalChain([periodUpdates, 'access', _55 => _55[0], 'optionalAccess', _56 => _56.data]);
+      const periodUpdate = _optionalChain([periodUpdates, 'access', _57 => _57[0], 'optionalAccess', _58 => _58.data]);
       const periodUpdateFinalizedSlot = periodUpdate ? BigInt(periodUpdate.finalized_header.beacon.slot) : void 0;
       const hasBridgeablePeriodUpdate = periodUpdateFinalizedSlot !== void 0 && periodUpdateFinalizedSlot <= maxBridgeableFinalizedSlot;
       let periodUpdateHasRequiredCommittee = !needsCommitteeData;
@@ -8361,7 +8438,7 @@ function buildFork(spec, name) {
   };
 }
 function hasNextSyncCommitteeUpdate(update) {
-  return !!_optionalChain([update, 'optionalAccess', _57 => _57.next_sync_committee]) && !!_optionalChain([update, 'optionalAccess', _58 => _58.next_sync_committee_branch]);
+  return !!_optionalChain([update, 'optionalAccess', _59 => _59.next_sync_committee]) && !!_optionalChain([update, 'optionalAccess', _60 => _60.next_sync_committee_branch]);
 }
 function getRequiredCommitteePeriod({
   storedPeriod,