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

package/browser/index.d.ts

@@ -13808,6 +13808,12 @@ type IBigIntLike = bigint | {
 };
 
 type ITxProgressCallback = (progressToInBlock: number, result?: TxResult) => void;
+type IBlockInclusion = {
+    blockHash: Uint8Array;
+    blockNumber?: number;
+    extrinsicIndex: number;
+    events: GenericEvent[];
+};
 declare class TxResult {
     #private;
     protected readonly client: ArgonClient;
@@ -13857,14 +13863,10 @@ declare class TxResult {
         accountAddress: string;
         nonce: number;
     });
-    setSeenInBlock(block: {
-        blockHash: Uint8Array;
-        blockNumber?: number;
-        extrinsicIndex: number;
-        events: GenericEvent[];
-    }): Promise<void>;
-    setFinalized(): void;
+    setSeenInBlock(block: IBlockInclusion): Promise<void>;
+    setFinalized(): Promise<void>;
     onSubscriptionResult(result: ISubmittableResult): void;
+    private publishSeenInBlock;
     private updateProgress;
     private parseEvents;
 }

package/browser/index.js

@@ -6,7 +6,7 @@ export { decodeAddress, encodeAddress, isAddress, mnemonicGenerate } from '@polk
 import { TypeRegistry, Metadata } from '@polkadot/types';
 import BigNumber4 from 'bignumber.js';
 import bs58check from 'bs58check';
-import { hexToU8a, u8aToHex } from '@polkadot/util';
+import { u8aEq, hexToU8a, u8aToHex } from '@polkadot/util';
 export { hexToU8a, u8aEq, u8aToHex } from '@polkadot/util';
 import { keccak256, stringToHex, encodeAbiParameters, toRlp, toHex, hexToBytes, bytesToHex, getAddress, decodeEventLog, createPublicClient, http } from 'viem';
 import { createBlockHeaderFromRPC } from '@ethereumjs/block';
@@ -215,13 +215,14 @@ function getBigIntFallback(value, source, fallbackFields, fallback = 0n) {
 }
 
 // src/TxResult.ts
-var _isBroadcast, _submissionError;
+var _isBroadcast, _submissionError, _pendingInBlock;
 var TxResult = class {
   constructor(client, extrinsic) {
     this.client = client;
     this.extrinsic = extrinsic;
     __privateAdd(this, _isBroadcast, false);
     __privateAdd(this, _submissionError);
+    __privateAdd(this, _pendingInBlock);
     __publicField(this, "waitForFinalizedBlock");
     __publicField(this, "waitForInFirstBlock");
     __publicField(this, "events", []);
@@ -278,21 +279,44 @@ var TxResult = class {
     return __privateGet(this, _submissionError);
   }
   async setSeenInBlock(block) {
-    const { blockHash, blockNumber, events } = block;
-    if (blockHash !== this.blockHash) {
-      this.parseEvents(events);
-      this.blockHash = blockHash;
-      this.blockNumber = blockNumber ?? 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) {
+      __privateSet(this, _pendingInBlock, {
+        blockHash: block.blockHash,
+        extrinsicIndex: block.extrinsicIndex,
+        events: block.events
+      });
+      return;
+    }
+    if (this.blockHash && this.blockNumber === block.blockNumber && this.extrinsicIndex === block.extrinsicIndex && u8aEq(this.blockHash, block.blockHash)) {
+      __privateSet(this, _pendingInBlock, void 0);
+      return;
+    }
+    __privateSet(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 = __privateGet(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 = this.extrinsicError ?? this.submissionError;
@@ -315,33 +339,73 @@ var TxResult = 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
+        );
+        __privateSet(this, _pendingInBlock, pendingInBlock);
+        void this.publishSeenInBlock(pendingInBlock).catch((error) => {
+          if (!isMissingBlockHeaderError(error)) {
+            this.submissionError = error;
+          }
+        });
+      } catch (error) {
+        this.submissionError = error;
+      }
     }
     if (status.isUsurped) {
+      __privateSet(this, _pendingInBlock, void 0);
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Usurped,
         `Transaction was usurped by ${status.asUsurped.toHex()}.`
       );
     }
     if (status.isDropped) {
+      __privateSet(this, _pendingInBlock, void 0);
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Dropped,
         "Transaction was dropped before it was included in a block."
       );
     }
     if (status.isInvalid) {
+      __privateSet(this, _pendingInBlock, void 0);
       this.submissionError = new TxSubmissionError(
         TxSubmissionErrorCode.Invalid,
         "Transaction was rejected as invalid by the node."
       );
     }
     if (isFinalized) {
-      this.setFinalized();
+      try {
+        __privateSet(this, _pendingInBlock, createPendingInBlock(
+          Uint8Array.from(status.asFinalized),
+          txIndex ?? __privateGet(this, _pendingInBlock)?.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 = __privateGet(this, _pendingInBlock);
+    if (!pendingInBlock || pendingInBlock.extrinsicIndex !== block.extrinsicIndex || !u8aEq(pendingInBlock.blockHash, block.blockHash)) {
+      return;
     }
+    const blockNumber = await this.client.rpc.chain.getHeader(block.blockHash).then((h) => h.number.toNumber());
+    const currentPendingInBlock = __privateGet(this, _pendingInBlock);
+    if (!currentPendingInBlock || currentPendingInBlock.extrinsicIndex !== block.extrinsicIndex || !u8aEq(currentPendingInBlock.blockHash, block.blockHash)) {
+      return;
+    }
+    await this.setSeenInBlock({
+      ...block,
+      blockNumber
+    });
   }
   updateProgress() {
     if (this.isFinalized || this.submissionError) {
@@ -390,6 +454,20 @@ var TxResult = class {
 };
 _isBroadcast = new WeakMap();
 _submissionError = new WeakMap();
+_pendingInBlock = new WeakMap();
+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 {