fix test and logging

packages/taler-wallet-cli/src/index.ts

@@ -226,6 +226,9 @@ async function withWallet<T>(
   const wallet = await getDefaultNodeWallet({
     persistentStoragePath: dbPath,
     httpLib: myHttpLib,
+    notifyHandler: (n) => {
+      logger.info(`wallet notification: ${j2s(n)}`);
+    },
   });
 
   if (checkEnvFlag("TALER_WALLET_BATCH_WITHDRAWAL")) {

packages/taler-wallet-cli/src/integrationtests/test-exchange-management.ts

@@ -189,17 +189,10 @@ export async function runExchangeManagementTest(
     });
   });
 
-  // Updating the exchange from the base URL is technically a pending operation
-  // and it will be retried later.
-  t.assertTrue(
-    err1.hasErrorCode(TalerErrorCode.WALLET_PENDING_OPERATION_FAILED),
-  );
-
   // Response is malformed, since it didn't even contain a version code
   // in a format the wallet can understand.
   t.assertTrue(
-    err1.errorDetail.innerError.code ===
+    err1.errorDetail.code === TalerErrorCode.WALLET_RECEIVED_MALFORMED_RESPONSE,
-      TalerErrorCode.WALLET_RECEIVED_MALFORMED_RESPONSE,
   );
 
   exchangesList = await wallet.client.call(
@@ -238,12 +231,9 @@ export async function runExchangeManagementTest(
   });
 
   t.assertTrue(
-    err2.hasErrorCode(TalerErrorCode.WALLET_PENDING_OPERATION_FAILED),
+    err2.hasErrorCode(
-  );
-
-  t.assertTrue(
-    err2.errorDetail.innerError.code ===
       TalerErrorCode.WALLET_EXCHANGE_PROTOCOL_VERSION_INCOMPATIBLE,
+    ),
   );
 
   exchangesList = await wallet.client.call(

packages/taler-wallet-cli/src/integrationtests/test-payment-claim.ts

@@ -102,14 +102,7 @@ export async function runPaymentClaimTest(t: GlobalTestState) {
     });
   });
 
-  t.assertTrue(
+  t.assertTrue(err.hasErrorCode(TalerErrorCode.WALLET_ORDER_ALREADY_CLAIMED));
-    err.hasErrorCode(TalerErrorCode.WALLET_PENDING_OPERATION_FAILED),
-  );
-
-  t.assertTrue(
-    err.errorDetail.innerError.code ===
-      TalerErrorCode.WALLET_ORDER_ALREADY_CLAIMED,
-  );
 
   await t.shutdown();
 }

packages/taler-wallet-core/src/errors.ts

@@ -102,7 +102,7 @@ export function summarizeTalerErrorDetail(ed: TalerErrorDetail): string {
 export class TalerError<T = any> extends Error {
   errorDetail: TalerErrorDetail & T;
   private constructor(d: TalerErrorDetail & T) {
-    super();
+    super(d.hint ?? `Error (code ${d.code})`);
     this.errorDetail = d;
     Object.setPrototypeOf(this, TalerError.prototype);
   }

packages/taler-wallet-core/src/wallet.ts

@@ -289,8 +289,9 @@ async function callOperationHandler(
         forceNow,
       });
     case PendingTaskType.Withdraw:
-      await processWithdrawalGroup(ws, pending.withdrawalGroupId, { forceNow });
+      return await processWithdrawalGroup(ws, pending.withdrawalGroupId, {
-      break;
+        forceNow,
+      });
     case PendingTaskType.ProposalDownload:
       return await processDownloadProposal(ws, pending.proposalId, {
         forceNow,
@@ -319,7 +320,7 @@ async function callOperationHandler(
     default:
       return assertUnreachable(pending);
   }
-  throw Error("not reached");
+  throw Error(`not reached ${pending.type}`);
 }
 
 export async function storeOperationError(
@@ -330,12 +331,17 @@ export async function storeOperationError(
   await ws.db
     .mktx((x) => [x.operationRetries])
     .runReadWrite(async (tx) => {
-      const retryRecord = await tx.operationRetries.get(pendingTaskId);
+      let retryRecord = await tx.operationRetries.get(pendingTaskId);
       if (!retryRecord) {
-        return;
+        retryRecord = {
-      }
+          id: pendingTaskId,
+          lastError: e,
+          retryInfo: RetryInfo.reset(),
+        };
+      } else {
         retryRecord.lastError = e;
         retryRecord.retryInfo = RetryInfo.increment(retryRecord.retryInfo);
+      }
       await tx.operationRetries.put(retryRecord);
     });
 }
@@ -358,12 +364,16 @@ export async function storeOperationPending(
   await ws.db
     .mktx((x) => [x.operationRetries])
     .runReadWrite(async (tx) => {
-      const retryRecord = await tx.operationRetries.get(pendingTaskId);
+      let retryRecord = await tx.operationRetries.get(pendingTaskId);
       if (!retryRecord) {
-        return;
+        retryRecord = {
-      }
+          id: pendingTaskId,
+          retryInfo: RetryInfo.reset(),
+        };
+      } else {
         delete retryRecord.lastError;
         retryRecord.retryInfo = RetryInfo.increment(retryRecord.retryInfo);
+      }
       await tx.operationRetries.put(retryRecord);
     });
 }
@@ -392,24 +402,18 @@ async function processOnePendingOperation(
       case OperationAttemptResultType.Longpoll:
         break;
     }
-  } catch (e: any) {
+  } catch (e) {
-    if (
+    if (e instanceof TalerError) {
-      e instanceof TalerError &&
-      e.hasErrorCode(TalerErrorCode.WALLET_PENDING_OPERATION_FAILED)
-    ) {
       logger.warn("operation processed resulted in error");
       logger.warn(`error was: ${j2s(e.errorDetail)}`);
       maybeError = e.errorDetail;
-    } else {
+      return await storeOperationError(ws, pending.id, maybeError!);
+    } else if (e instanceof Error) {
       // This is a bug, as we expect pending operations to always
       // do their own error handling and only throw WALLET_PENDING_OPERATION_FAILED
       // or return something.
-      logger.error("Uncaught exception", e);
+      logger.error(`Uncaught exception: ${e.message}`);
-      ws.notify({
+      logger.error(`Stack: ${e.stack}`);
-        type: NotificationType.InternalError,
-        message: "uncaught exception",
-        exception: e,
-      });
       maybeError = makeErrorDetail(
         TalerErrorCode.WALLET_UNEXPECTED_EXCEPTION,
         {
@@ -417,6 +421,15 @@ async function processOnePendingOperation(
         },
         `unexpected exception (message: ${e.message})`,
       );
+      return await storeOperationError(ws, pending.id, maybeError);
+    } else {
+      logger.error("Uncaught exception, value is not even an error.");
+      maybeError = makeErrorDetail(
+        TalerErrorCode.WALLET_UNEXPECTED_EXCEPTION,
+        {},
+        `unexpected exception (not even an error)`,
+      );
+      return await storeOperationError(ws, pending.id, maybeError);
     }
   }
 }