Check if isCompleted is undefined

package.json

@@ -36,6 +36,7 @@
   },
   "devDependencies": {
     "@multiversx/sdk-network-providers": "1.2.1",
+    "@multiversx/sdk-network-providers-next": "npm:@multiversx/sdk-network-providers@1.6.0-beta.0",
     "@multiversx/sdk-wallet": "3.0.0",
     "@multiversx/sdk-wallet-next": "npm:@multiversx/sdk-wallet@4.0.0",
     "@types/assert": "1.4.6",

src/errors.ts

@@ -325,3 +325,9 @@ export class ErrGasLimitShouldBe0ForInnerTransaction extends Err {
     super("gas limit must be 0 for the inner transaction for relayed v2");
   }
 }
+
+export class ErrIsCompletedFieldIsMissingOnTransaction extends Err {
+  public constructor() {
+    super("The transaction watcher requires the `isCompleted` property to be defined on the transaction object. Perhaps you've used the sdk-network-provider's `getTransaction()` and in that case you should also pass `withProcessStatus=true`.")
+  }
+}

src/interfaceOfNetwork.ts

@@ -13,8 +13,8 @@ export interface INetworkConfig {
 }
 
 export interface ITransactionOnNetwork {
-    isCompleted: boolean;
-    
+    isCompleted?: boolean;
+
     hash: string;
     type: string;
     value: string;

src/transaction.local.net.spec.ts

@@ -7,6 +7,7 @@ import { TokenTransfer } from "./tokenTransfer";
 import { Transaction } from "./transaction";
 import { TransactionPayload } from "./transactionPayload";
 import { TransactionWatcher } from "./transactionWatcher";
+import { ProxyNetworkProvider } from "@multiversx/sdk-network-providers-next";
 
 describe("test transaction", function () {
     let alice: TestWallet, bob: TestWallet;
@@ -15,8 +16,8 @@ describe("test transaction", function () {
         ({ alice, bob } = await loadTestWallets());
     });
 
-    it("should send transactions", async function () {
-        this.timeout(30000);
+    it("should send transactions and wait for completion", async function () {
+        this.timeout(70000);
 
         let provider = createLocalnetProvider();
         let watcher = new TransactionWatcher(provider);
@@ -62,6 +63,40 @@ describe("test transaction", function () {
         assert.deepEqual(TokenTransfer.egldFromAmount(85).valueOf(), newBalanceOfBob.minus(initialBalanceOfBob));
     });
 
+    it("should send transaction and wait for completion using the new proxy provider", async function () {
+        this.timeout(70000);
+
+        let provider = createLocalnetProvider();
+        let newProvider = new ProxyNetworkProvider("http://localhost:7950", { timeout: 5000 });
+        let watcher = new TransactionWatcher({
+            getTransaction: async (hash: string) => { return await newProvider.getTransaction(hash, true) }
+        });
+
+        let network = await provider.getNetworkConfig();
+
+        await alice.sync(provider);
+        await bob.sync(provider);
+        let initialBalanceOfBob = new BigNumber(bob.account.balance.toString());
+
+        let transactionOne = new Transaction({
+            sender: alice.address,
+            receiver: bob.address,
+            value: TokenTransfer.egldFromAmount(42),
+            gasLimit: network.MinGasLimit,
+            chainID: network.ChainID
+        });
+
+        transactionOne.setNonce(alice.account.nonce);
+        await signTransaction({ transaction: transactionOne, wallet: alice });
+        await provider.sendTransaction(transactionOne);
+        await watcher.awaitCompleted(transactionOne);
+
+        await bob.sync(provider);
+        let newBalanceOfBob = new BigNumber(bob.account.balance.toString());
+
+        assert.deepEqual(TokenTransfer.egldFromAmount(42).valueOf(), newBalanceOfBob.minus(initialBalanceOfBob));
+    });
+
     it("should simulate transactions", async function () {
         this.timeout(20000);
 

src/transactionWatcher.ts

@@ -1,5 +1,5 @@
 import { AsyncTimer } from "./asyncTimer";
-import { Err, ErrExpectedTransactionEventsNotFound, ErrExpectedTransactionStatusNotReached } from "./errors";
+import { Err, ErrExpectedTransactionEventsNotFound, ErrExpectedTransactionStatusNotReached, ErrIsCompletedFieldIsMissingOnTransaction } from "./errors";
 import { ITransactionFetcher } from "./interface";
 import { ITransactionEvent, ITransactionOnNetwork, ITransactionStatus } from "./interfaceOfNetwork";
 import { Logger } from "./logger";
@@ -69,7 +69,13 @@ export class TransactionWatcher {
       * Waits until the transaction is completely processed.
       */
     public async awaitCompleted(transaction: ITransaction): Promise<ITransactionOnNetwork> {
-        const isCompleted = (transactionOnNetwork: ITransactionOnNetwork) => transactionOnNetwork.isCompleted;
+        const isCompleted = (transactionOnNetwork: ITransactionOnNetwork) => {
+            if (transactionOnNetwork.isCompleted === undefined) {
+                throw new ErrIsCompletedFieldIsMissingOnTransaction();
+            }
+            return transactionOnNetwork.isCompleted
+        };
+
         const doFetch = async () => await this.fetcher.getTransaction(transaction.getHash().hex());
         const errorProvider = () => new ErrExpectedTransactionStatusNotReached();
 
@@ -155,6 +161,10 @@ export class TransactionWatcher {
             } catch (error) {
                 Logger.debug("TransactionWatcher.awaitConditionally(): cannot (yet) fetch data.");
 
+                if (error instanceof ErrIsCompletedFieldIsMissingOnTransaction) {
+                    throw error;
+                }
+
                 if (!(error instanceof Err)) {
                     throw error;
                 }