fixup! feat(core): add timeout and logger to the tokenTransferInspector and transactionSummaryInspector

add promiseTimeout util, new TimeoutError and tests

Author: przemyslaw-wlodek

packages/core/src/errors.ts

@@ -78,3 +78,9 @@ export class NotImplementedError extends CustomError {
     super(`Not implemented: ${missingFeature}`);
   }
 }
+
+export class TimeoutError extends CustomError {
+  public constructor(message: string) {
+    super(`Timeout: ${message}`);
+  }
+}

packages/core/src/util/promiseTimeout.ts

@@ -0,0 +1,17 @@
+/* eslint-disable promise/param-names */
+
+import { TimeoutError } from '../errors';
+
+export const promiseTimeout = <T>(promise: Promise<T>, timeout: number) => {
+  let timeoutId: NodeJS.Timeout;
+
+  return Promise.race([
+    promise,
+    new Promise<T>(
+      (_, reject) =>
+        (timeoutId = setTimeout(() => reject(new TimeoutError('Failed to resolve the promise in time')), timeout))
+    )
+  ]).finally(() => {
+    if (timeoutId) clearTimeout(timeoutId);
+  });
+};

packages/core/src/util/tokenTransferInspector.ts

@@ -5,7 +5,9 @@ import { AssetProvider } from '../Provider';
 import { Inspector, ResolutionResult, resolveInputs } from './txInspector';
 import { Logger } from 'ts-log';
 import { Milliseconds } from './time';
+import { TimeoutError } from '../errors';
 import { coalesceValueQuantities } from './coalesceValueQuantities';
+import { promiseTimeout } from './promiseTimeout';
 import { subtractValueQuantities } from './subtractValueQuantities';
 import uniq from 'lodash/uniq';
 
@@ -157,33 +159,18 @@ const toTokenTransferValue = async (
   return tokenTransferValue;
 };
 
-/**
- * Resolve inputs with a timeout so that if the inputs fail to resolve in n Miliseconds
- * we throw an error so the UI consumer can handle situation accordingly.
- * In this case we create a race condition in which we race to send the resolved inputs before the
- * timeout, and timeout only if the inputs aren't there.
- */
-export const resolveWithTimeout = <T>(promise: Promise<T>, timeout: Milliseconds): Promise<T> =>
-  Promise.race([
-    promise,
-    new Promise<T>((_, reject) =>
-      setTimeout(() => reject(new Error('Timeout: failed to resolve inputs in time')), timeout)
-    )
-  ]);
-
 /** Inspect a transaction and return a map of addresses and their balances. */
 export const tokenTransferInspector: TokenTransferInspector =
   ({ inputResolver, fromAddressAssetProvider, toAddressAssetProvider, timeout, logger }) =>
   async (tx) => {
     let resolvedInputs: ResolutionResult['resolvedInputs'];
 
     try {
-      const inputResolution = await resolveWithTimeout(resolveInputs(tx.body.inputs, inputResolver), timeout);
+      const inputResolution = await promiseTimeout(resolveInputs(tx.body.inputs, inputResolver), timeout);
       resolvedInputs = inputResolution.resolvedInputs;
     } catch (error) {
-      if (error === 'Timeout: failed to resolve inputs in time') {
-        // Handle timeout error specifically
-        logger.log('Error: Inputs resolution timed out');
+      if (error instanceof TimeoutError) {
+        logger.error('Error: Inputs resolution timed out');
       }
 
       resolvedInputs = [];

packages/core/src/util/transactionSummaryInspector.ts

@@ -1,7 +1,7 @@
 import * as Cardano from '../Cardano';
 import * as Crypto from '@cardano-sdk/crypto';
 import { AssetId, TokenMap } from '../Cardano';
-import { AssetInfoWithAmount, resolveWithTimeout } from './tokenTransferInspector';
+import { AssetInfoWithAmount } from './tokenTransferInspector';
 import { AssetProvider } from '../Provider';
 import {
   AssetsMintedInspection,
@@ -16,9 +16,11 @@ import {
 import { BigIntMath } from '@cardano-sdk/util';
 import { Logger } from 'ts-log';
 import { Milliseconds } from './time';
+import { TimeoutError } from '../errors';
 import { coalesceTokenMaps, subtractTokenMaps } from '../Asset/util';
 import { coalesceValueQuantities } from './coalesceValueQuantities';
 import { computeImplicitCoin } from '../Cardano/util';
+import { promiseTimeout } from './promiseTimeout';
 import { subtractValueQuantities } from './subtractValueQuantities';
 
 interface TransactionSummaryInspectorArgs {
@@ -29,7 +31,7 @@ interface TransactionSummaryInspectorArgs {
   assetProvider: AssetProvider;
   dRepKeyHash?: Crypto.Ed25519KeyHashHex;
   timeout: Milliseconds;
-  logger?: Logger;
+  logger: Logger;
 }
 
 export type TransactionSummaryInspection = {
@@ -150,27 +152,24 @@ const toAssetInfoWithAmount = async (
  * @param {TransactionSummaryInspectorArgs} args The arguments for the inspector.
  */
 export const transactionSummaryInspector: TransactionSummaryInspector =
-  (args: TransactionSummaryInspectorArgs) => async (tx) => {
-    const {
-      inputResolver,
-      addresses,
-      rewardAccounts,
-      protocolParameters,
-      assetProvider,
-      dRepKeyHash,
-      timeout,
-      logger
-    } = args;
-
+  ({
+    inputResolver,
+    addresses,
+    rewardAccounts,
+    protocolParameters,
+    assetProvider,
+    dRepKeyHash,
+    timeout,
+    logger
+  }: TransactionSummaryInspectorArgs) =>
+  async (tx) => {
     let resolvedInputs: ResolutionResult;
 
     try {
-      // eslint-disable-next-line sonarjs/prefer-immediate-return
-      resolvedInputs = await resolveWithTimeout(resolveInputs(tx.body.inputs, inputResolver), timeout);
+      resolvedInputs = await promiseTimeout(resolveInputs(tx.body.inputs, inputResolver), timeout);
     } catch (error) {
-      if (error === 'Timeout: failed to resolve inputs in time') {
-        // Handle timeout error specifically
-        logger?.log('Error: Inputs resolution timed out');
+      if (error instanceof TimeoutError) {
+        logger.error('Error: Inputs resolution timed out');
       }
 
       resolvedInputs = {

packages/core/test/util/tokenTransferInspector.test.ts

@@ -22,13 +22,17 @@ const buildTokenTransferValue = (coins: bigint, assets: Array<[Asset.AssetInfo,
   coins
 });
 
-const createMockInputResolver = (historicalTxs: Cardano.HydratedTx[]): Cardano.InputResolver => ({
+const createMockInputResolver = (historicalTxs: Cardano.HydratedTx[], resolveDelay = 0): Cardano.InputResolver => ({
   async resolveInput(input: Cardano.TxIn) {
     const tx = historicalTxs.find((historicalTx) => historicalTx.id === input.txId);
 
     if (!tx || tx.body.outputs.length <= input.index) return Promise.resolve(null);
 
-    return Promise.resolve(tx.body.outputs[input.index]);
+    return await new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(tx.body.outputs[input.index]);
+      }, resolveDelay);
+    });
   }
 });
 
@@ -1069,5 +1073,75 @@ describe('txInspector', () => {
         ])
       );
     });
+
+    it.only('has no resolved fromAddresses on timeout', async () => {
+      const resolveDelay = 5;
+      const timeoutAfter = Milliseconds(1);
+
+      const tx = buildMockTx({
+        inputs: [
+          {
+            address: addresses[0],
+            index: 0,
+            txId: Cardano.TransactionId('bb217abaca60fc0ca68c1555eca6a96d2478547818ae76ce6836133f3cc546e0')
+          },
+          {
+            address: addresses[1],
+            index: 0,
+            txId: Cardano.TransactionId('bb217abaca60fc0ca68c1555eca6a96d2478547818ae76ce6836133f3cc546e0')
+          }
+        ],
+        outputs: [
+          {
+            address: addresses[0],
+            value: {
+              assets: new Map([
+                [AssetIds.TSLA, 100n],
+                [AssetIds.PXL, 50n],
+                [AssetIds.Unit, 30n]
+              ]),
+              coins: 3_000_000n
+            }
+          }
+        ]
+      });
+
+      const histTx: Cardano.HydratedTx[] = [
+        {
+          body: {
+            outputs: [
+              {
+                address: addresses[0],
+                value: {
+                  assets: new Map([
+                    [AssetIds.TSLA, 25n],
+                    [AssetIds.PXL, 10n],
+                    [AssetIds.Unit, 5n]
+                  ]),
+                  coins: 3_000_000n
+                }
+              }
+            ]
+          },
+          id: Cardano.TransactionId('bb217abaca60fc0ca68c1555eca6a96d2478547818ae76ce6836133f3cc546e0')
+        } as unknown as Cardano.HydratedTx
+      ];
+
+      const inspectTx = createTxInspector({
+        tokenTransfer: tokenTransferInspector({
+          fromAddressAssetProvider: assetProvider,
+          inputResolver: createMockInputResolver(histTx, resolveDelay),
+          logger,
+          timeout: timeoutAfter,
+          toAddressAssetProvider: assetProvider
+        })
+      });
+
+      // Act
+      const { tokenTransfer } = await inspectTx(tx);
+
+      // Assert
+      expect(tokenTransfer.fromAddress).toEqual(new Map([]));
+    });
   });
 });