pretty

12 files changed, 831 insertions, 674 deletions

diff --git a/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerWeb.ts b/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerWeb.ts
index 29762f598..cbf1e19f7 100644
--- a/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerWeb.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/synchronousWorkerWeb.ts
@@ -20,8 +20,6 @@ import {
   TalerCryptoInterfaceR,
 } from "../cryptoImplementation.js";
 
-
-
 const logger = new Logger("synchronousWorker.ts");
 
 /**
diff --git a/packages/taler-wallet-core/src/operations/backup/index.ts b/packages/taler-wallet-core/src/operations/backup/index.ts
index d4dfe2916..c7c93e909 100644
--- a/packages/taler-wallet-core/src/operations/backup/index.ts
+++ b/packages/taler-wallet-core/src/operations/backup/index.ts
@@ -86,7 +86,12 @@ import {
   checkDbInvariant,
   checkLogicInvariant,
 } from "../../util/invariants.js";
-import { OperationAttemptResult, OperationAttemptResultType, RetryTags, scheduleRetryInTx } from "../../util/retries.js";
+import {
+  OperationAttemptResult,
+  OperationAttemptResultType,
+  RetryTags,
+  scheduleRetryInTx,
+} from "../../util/retries.js";
 import {
   checkPaymentByProposalId,
   confirmPay,
diff --git a/packages/taler-wallet-core/src/operations/deposits.ts b/packages/taler-wallet-core/src/operations/deposits.ts
index c16b2376d..54fd323de 100644
--- a/packages/taler-wallet-core/src/operations/deposits.ts
+++ b/packages/taler-wallet-core/src/operations/deposits.ts
@@ -505,7 +505,7 @@ export async function createDepositGroup(
 
   return {
     depositGroupId: depositGroupId,
-    transactionId: makeEventId(TransactionType.Deposit, depositGroupId)
+    transactionId: makeEventId(TransactionType.Deposit, depositGroupId),
   };
 }
 
diff --git a/packages/taler-wallet-core/src/operations/exchanges.ts b/packages/taler-wallet-core/src/operations/exchanges.ts
index 9165ed050..8d1f58893 100644
--- a/packages/taler-wallet-core/src/operations/exchanges.ts
+++ b/packages/taler-wallet-core/src/operations/exchanges.ts
@@ -64,7 +64,12 @@ import {
   readSuccessResponseTextOrThrow,
 } from "../util/http.js";
 import { DbAccess, GetReadOnlyAccess } from "../util/query.js";
-import { OperationAttemptResult, OperationAttemptResultType, RetryInfo, runOperationHandlerForResult } from "../util/retries.js";
+import {
+  OperationAttemptResult,
+  OperationAttemptResultType,
+  RetryInfo,
+  runOperationHandlerForResult,
+} from "../util/retries.js";
 import { WALLET_EXCHANGE_PROTOCOL_VERSION } from "../versions.js";
 import { guardOperationException } from "./common.js";
 
diff --git a/packages/taler-wallet-core/src/operations/pay.ts b/packages/taler-wallet-core/src/operations/pay.ts
index 468f9ca31..52b23713d 100644
--- a/packages/taler-wallet-core/src/operations/pay.ts
+++ b/packages/taler-wallet-core/src/operations/pay.ts
@@ -97,7 +97,13 @@ import {
   throwUnexpectedRequestError,
 } from "../util/http.js";
 import { checkDbInvariant, checkLogicInvariant } from "../util/invariants.js";
-import { OperationAttemptResult, OperationAttemptResultType, RetryInfo, RetryTags, scheduleRetry } from "../util/retries.js";
+import {
+  OperationAttemptResult,
+  OperationAttemptResultType,
+  RetryInfo,
+  RetryTags,
+  scheduleRetry,
+} from "../util/retries.js";
 import { spendCoins } from "../wallet.js";
 import { getExchangeDetails } from "./exchanges.js";
 import { getTotalRefreshCost } from "./refresh.js";
diff --git a/packages/taler-wallet-core/src/operations/recoup.ts b/packages/taler-wallet-core/src/operations/recoup.ts
index 4424b9b40..119119035 100644
--- a/packages/taler-wallet-core/src/operations/recoup.ts
+++ b/packages/taler-wallet-core/src/operations/recoup.ts
@@ -52,7 +52,11 @@ import {
 import { InternalWalletState } from "../internal-wallet-state.js";
 import { readSuccessResponseJsonOrThrow } from "../util/http.js";
 import { GetReadWriteAccess } from "../util/query.js";
-import { OperationAttemptResult, RetryInfo, runOperationHandlerForResult } from "../util/retries.js";
+import {
+  OperationAttemptResult,
+  RetryInfo,
+  runOperationHandlerForResult,
+} from "../util/retries.js";
 import { guardOperationException } from "./common.js";
 import { createRefreshGroup, processRefreshGroup } from "./refresh.js";
 import { internalCreateWithdrawalGroup } from "./withdraw.js";
diff --git a/packages/taler-wallet-core/src/operations/tip.ts b/packages/taler-wallet-core/src/operations/tip.ts
index f79851be8..571721658 100644
--- a/packages/taler-wallet-core/src/operations/tip.ts
+++ b/packages/taler-wallet-core/src/operations/tip.ts
@@ -52,7 +52,10 @@ import {
   readSuccessResponseJsonOrThrow,
 } from "../util/http.js";
 import { checkDbInvariant, checkLogicInvariant } from "../util/invariants.js";
-import { OperationAttemptResult, OperationAttemptResultType } from "../util/retries.js";
+import {
+  OperationAttemptResult,
+  OperationAttemptResultType,
+} from "../util/retries.js";
 import { makeCoinAvailable } from "../wallet.js";
 import { updateExchangeFromUrl } from "./exchanges.js";
 import { makeEventId } from "./transactions.js";
@@ -362,9 +365,6 @@ export async function acceptTip(
     await processTip(ws, tipId);
   }
   return {
-    transactionId: makeEventId(
-      TransactionType.Tip,
-      tipId
-    )
-  }
+    transactionId: makeEventId(TransactionType.Tip, tipId),
+  };
 }
diff --git a/packages/taler-wallet-core/src/operations/withdraw.ts b/packages/taler-wallet-core/src/operations/withdraw.ts
index 6b31842b3..de9721f3d 100644
--- a/packages/taler-wallet-core/src/operations/withdraw.ts
+++ b/packages/taler-wallet-core/src/operations/withdraw.ts
@@ -93,7 +93,10 @@ import {
 } from "../util/http.js";
 import { checkDbInvariant, checkLogicInvariant } from "../util/invariants.js";
 import { DbAccess, GetReadOnlyAccess } from "../util/query.js";
-import { OperationAttemptResult, OperationAttemptResultType } from "../util/retries.js";
+import {
+  OperationAttemptResult,
+  OperationAttemptResultType,
+} from "../util/retries.js";
 import {
   WALLET_BANK_INTEGRATION_PROTOCOL_VERSION,
   WALLET_EXCHANGE_PROTOCOL_VERSION,
@@ -258,7 +261,7 @@ export function selectWithdrawalDenominations(
       DenominationRecord.getValue(d),
       d.fees.feeWithdraw,
     ).amount;
-    for (; ;) {
+    for (;;) {
       if (Amounts.cmp(remaining, cost) < 0) {
         break;
       }
@@ -900,7 +903,8 @@ export async function updateWithdrawalDenoms(
         denom.verificationStatus === DenominationVerificationStatus.Unverified
       ) {
         logger.trace(
-          `Validating denomination (${current + 1}/${denominations.length
+          `Validating denomination (${current + 1}/${
+            denominations.length
           }) signature of ${denom.denomPubHash}`,
         );
         let valid = false;
@@ -983,7 +987,7 @@ async function queryReserve(
     if (
       resp.status === 404 &&
       result.talerErrorResponse.code ===
-      TalerErrorCode.EXCHANGE_RESERVES_STATUS_UNKNOWN
+        TalerErrorCode.EXCHANGE_RESERVES_STATUS_UNKNOWN
     ) {
       ws.notify({
         type: NotificationType.ReserveNotYetFound,
@@ -1305,7 +1309,7 @@ export async function getExchangeWithdrawalInfo(
     ) {
       logger.warn(
         `wallet's support for exchange protocol version ${WALLET_EXCHANGE_PROTOCOL_VERSION} might be outdated ` +
-        `(exchange has ${exchangeDetails.protocolVersion}), checking for updates`,
+          `(exchange has ${exchangeDetails.protocolVersion}), checking for updates`,
       );
     }
   }
@@ -1804,7 +1808,7 @@ export async function acceptWithdrawalFromUri(
       transactionId: makeEventId(
         TransactionType.Withdrawal,
         existingWithdrawalGroup.withdrawalGroupId,
-      )
+      ),
     };
   }
 
@@ -1862,10 +1866,7 @@ export async function acceptWithdrawalFromUri(
   return {
     reservePub: withdrawalGroup.reservePub,
     confirmTransferUrl: withdrawInfo.confirmTransferUrl,
-    transactionId: makeEventId(
-      TransactionType.Withdrawal,
-      withdrawalGroupId,
-    )
+    transactionId: makeEventId(TransactionType.Withdrawal, withdrawalGroupId),
   };
 }
 
@@ -1920,9 +1921,6 @@ export async function createManualWithdrawal(
   return {
     reservePub: withdrawalGroup.reservePub,
     exchangePaytoUris: exchangePaytoUris,
-    transactionId: makeEventId(
-      TransactionType.Withdrawal,
-      withdrawalGroupId,
-    )
+    transactionId: makeEventId(TransactionType.Withdrawal, withdrawalGroupId),
   };
 }
diff --git a/packages/taler-wallet-core/src/util/denominations.test.ts b/packages/taler-wallet-core/src/util/denominations.test.ts
index 653692437..31c561e88 100644
--- a/packages/taler-wallet-core/src/util/denominations.test.ts
+++ b/packages/taler-wallet-core/src/util/denominations.test.ts
@@ -19,420 +19,493 @@
  * @author Sebastian Javier Marchano (sebasjm)
  */
 
- import {
-  AbsoluteTime,FeeDescription, FeeDescriptionPair,
-  Amounts, DenominationInfo
+import {
+  AbsoluteTime,
+  FeeDescription,
+  FeeDescriptionPair,
+  Amounts,
+  DenominationInfo,
 } from "@gnu-taler/taler-util";
 // import { expect } from "chai";
-import { createDenominationPairTimeline, createDenominationTimeline } from "./denominations.js";
+import {
+  createDenominationPairTimeline,
+  createDenominationTimeline,
+} from "./denominations.js";
 import test, { ExecutionContext } from "ava";
 
 /**
  * Create some constants to be used as reference in the tests
  */
-const VALUES = Array.from({ length: 10 }).map((undef, t) => Amounts.parseOrThrow(`USD:${t}`))
-const TIMESTAMPS = Array.from({ length: 20 }).map((undef, t_s) => ({ t_s }))
-const ABS_TIME = TIMESTAMPS.map(m => AbsoluteTime.fromTimestamp(m))
+const VALUES = Array.from({ length: 10 }).map((undef, t) =>
+  Amounts.parseOrThrow(`USD:${t}`),
+);
+const TIMESTAMPS = Array.from({ length: 20 }).map((undef, t_s) => ({ t_s }));
+const ABS_TIME = TIMESTAMPS.map((m) => AbsoluteTime.fromTimestamp(m));
 
 function normalize(list: DenominationInfo[]): DenominationInfo[] {
-  return list.map((e, idx) => ({ ...e, denomPubHash: `id${idx}` }))
+  return list.map((e, idx) => ({ ...e, denomPubHash: `id${idx}` }));
 }
 
 //Avoiding to make an error-prone/time-consuming refactor
 //this function calls AVA's deepEqual from a chai interface
-function expect(t:ExecutionContext, thing: any):any {
+function expect(t: ExecutionContext, thing: any): any {
   return {
     deep: {
-      equal: (another:any) => t.deepEqual(thing,another),
-      equals: (another:any) => t.deepEqual(thing,another),
-    }
-  }
+      equal: (another: any) => t.deepEqual(thing, another),
+      equals: (another: any) => t.deepEqual(thing, another),
+    },
+  };
 }
 
 // describe("Denomination timeline creation", (t) => {
 //   describe("single value example", (t) => {
 
-    test("should have one row with start and exp", (t) => {
-
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[2],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+test("should have one row with start and exp", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[1],
-      } as FeeDescription])
-    });
-
-    test("should have two rows with the second denom in the middle if second is better", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[2],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[1],
+    } as FeeDescription,
+  ]);
+});
+
+test("should have two rows with the second denom in the middle if second is better", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[3],
-        fee: VALUES[1],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[3],
-        until: ABS_TIME[4],
-        fee: VALUES[2],
-      }] as FeeDescription[])
-
-    });
-
-    test("should have two rows with the first denom in the middle if second is worse", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[3],
+      until: ABS_TIME[4],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should have two rows with the first denom in the middle if second is worse", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[4],
-        fee: VALUES[1],
-      }] as FeeDescription[])
-
-    });
-
-    test("should add a gap when there no fee", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[2],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[3],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[4],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should add a gap when there no fee", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[2],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[3],
-
-      }, {
+        stampStart: TIMESTAMPS[3],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[3],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[3],
+      until: ABS_TIME[4],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should have three rows when first denom is between second and second is worse", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[3],
-        until: ABS_TIME[4],
-        fee: VALUES[1],
-      }] as FeeDescription[])
-
-    });
-
-    test("should have three rows when first denom is between second and second is worse", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[3],
+      until: ABS_TIME[4],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should have one row when first denom is between second and second is better", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[3],
-        fee: VALUES[1],
-      }, {
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[3],
-        until: ABS_TIME[4],
-        fee: VALUES[2],
-      }] as FeeDescription[])
-
-    });
-
-    test("should have one row when first denom is between second and second is better", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[4],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should only add the best1", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[4],
-        fee: VALUES[1],
-      }] as FeeDescription[])
-
-    });
-
-    test("should only add the best1", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[4],
-        fee: VALUES[1],
-      }] as FeeDescription[])
-
-    });
-
-    test("should only add the best2", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[5],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[5],
-          stampExpireDeposit: TIMESTAMPS[6],
-          feeDeposit: VALUES[3]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[4],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should only add the best2", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[5],
-        fee: VALUES[1],
-      }, {
-        value: VALUES[1],
-        from: ABS_TIME[5],
-        until: ABS_TIME[6],
-        fee: VALUES[3],
-      }] as FeeDescription[])
-
-    });
-
-    test("should only add the best3", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[5],
-          feeDeposit: VALUES[3]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[5],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[5],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[5],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[2],
-        until: ABS_TIME[5],
-        fee: VALUES[1],
-      }] as FeeDescription[])
-
-    })
-  // })
-
-  // describe("multiple value example", (t) => {
-
-    //TODO: test the same start but different value
-
-    test("should not merge when there is different value", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[2],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[3],
-        fee: VALUES[1],
-      }, {
+        stampStart: TIMESTAMPS[5],
+        stampExpireDeposit: TIMESTAMPS[6],
+        feeDeposit: VALUES[3],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[5],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[5],
+      until: ABS_TIME[6],
+      fee: VALUES[3],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should only add the best3", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
+        value: VALUES[1],
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[5],
+        feeDeposit: VALUES[3],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
+        value: VALUES[1],
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[5],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
+        value: VALUES[1],
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[5],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[5],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[]);
+});
+// })
+
+// describe("multiple value example", (t) => {
+
+//TODO: test the same start but different value
+
+test("should not merge when there is different value", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
+        value: VALUES[1],
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[2],
-        from: ABS_TIME[2],
-        until: ABS_TIME[4],
-        fee: VALUES[2],
-      }] as FeeDescription[])
-
-    });
-
-    test("should not merge when there is different value (with duplicates)", (t) => {
-      const timeline = createDenominationTimeline(normalize([
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[2],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[1],
-          stampStart: TIMESTAMPS[1],
-          stampExpireDeposit: TIMESTAMPS[3],
-          feeDeposit: VALUES[1]
-        } as Partial<DenominationInfo> as DenominationInfo,
-        {
-          value: VALUES[2],
-          stampStart: TIMESTAMPS[2],
-          stampExpireDeposit: TIMESTAMPS[4],
-          feeDeposit: VALUES[2]
-        } as Partial<DenominationInfo> as DenominationInfo,
-      ]), "stampExpireDeposit", "feeDeposit");
-
-      expect(t,timeline).deep.equal([{
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[2],
+      from: ABS_TIME[2],
+      until: ABS_TIME[4],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[]);
+});
+
+test("should not merge when there is different value (with duplicates)", (t) => {
+  const timeline = createDenominationTimeline(
+    normalize([
+      {
         value: VALUES[1],
-        from: ABS_TIME[1],
-        until: ABS_TIME[3],
-        fee: VALUES[1],
-      }, {
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
         value: VALUES[2],
-        from: ABS_TIME[2],
-        until: ABS_TIME[4],
-        fee: VALUES[2],
-      }] as FeeDescription[])
-
-    });
-
-    // it.skip("real world example: bitcoin exchange", (t) => {
-    //   const timeline = createDenominationTimeline(
-    //     bitcoinExchanges[0].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
-    //     "stampExpireDeposit", "feeDeposit");
-
-    //   expect(t,timeline).deep.equal([{
-    //     fee: Amounts.parseOrThrow('BITCOINBTC:0.00000001'),
-    //     from: { t_ms: 1652978648000 },
-    //     until: { t_ms: 1699633748000 },
-    //     value: Amounts.parseOrThrow('BITCOINBTC:0.01048576'),
-    //   }, {
-    //     fee: Amounts.parseOrThrow('BITCOINBTC:0.00000003'),
-    //     from: { t_ms: 1699633748000 },
-    //     until: { t_ms: 1707409448000 },
-    //     value: Amounts.parseOrThrow('BITCOINBTC:0.01048576'),
-    //   }] as FeeDescription[])
-    // })
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
+        value: VALUES[1],
+        stampStart: TIMESTAMPS[1],
+        stampExpireDeposit: TIMESTAMPS[3],
+        feeDeposit: VALUES[1],
+      } as Partial<DenominationInfo> as DenominationInfo,
+      {
+        value: VALUES[2],
+        stampStart: TIMESTAMPS[2],
+        stampExpireDeposit: TIMESTAMPS[4],
+        feeDeposit: VALUES[2],
+      } as Partial<DenominationInfo> as DenominationInfo,
+    ]),
+    "stampExpireDeposit",
+    "feeDeposit",
+  );
+
+  expect(t, timeline).deep.equal([
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[2],
+      from: ABS_TIME[2],
+      until: ABS_TIME[4],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[]);
+});
+
+// it.skip("real world example: bitcoin exchange", (t) => {
+//   const timeline = createDenominationTimeline(
+//     bitcoinExchanges[0].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
+//     "stampExpireDeposit", "feeDeposit");
+
+//   expect(t,timeline).deep.equal([{
+//     fee: Amounts.parseOrThrow('BITCOINBTC:0.00000001'),
+//     from: { t_ms: 1652978648000 },
+//     until: { t_ms: 1699633748000 },
+//     value: Amounts.parseOrThrow('BITCOINBTC:0.01048576'),
+//   }, {
+//     fee: Amounts.parseOrThrow('BITCOINBTC:0.00000003'),
+//     from: { t_ms: 1699633748000 },
+//     until: { t_ms: 1707409448000 },
+//     value: Amounts.parseOrThrow('BITCOINBTC:0.01048576'),
+//   }] as FeeDescription[])
+// })
 
 //   })
 
@@ -442,271 +515,304 @@ function expect(t:ExecutionContext, thing: any):any {
 
 //   describe("single value example", (t) => {
 
-    test("should return empty", (t) => {
+test("should return empty", (t) => {
+  const left = [] as FeeDescription[];
+  const right = [] as FeeDescription[];
 
-      const left = [] as FeeDescription[];
-      const right = [] as FeeDescription[];
+  const pairs = createDenominationPairTimeline(left, right);
 
-      const pairs = createDenominationPairTimeline(left, right)
+  expect(t, pairs).deep.equals([]);
+});
 
-      expect(t,pairs).deep.equals([])
-    });
+test("should return first element", (t) => {
+  const left = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[];
 
-    test("should return first element", (t) => {
+  const right = [] as FeeDescription[];
 
-      const left = [{
-        value: VALUES[1],
+  {
+    const pairs = createDenominationPairTimeline(left, right);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[1],
-      }] as FeeDescription[];
-
-      const right = [] as FeeDescription[];
-
-      {
-        const pairs = createDenominationPairTimeline(left, right)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: undefined,
-        }] as FeeDescriptionPair[])
-      }
-      {
-        const pairs = createDenominationPairTimeline(right, left)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          right: VALUES[1],
-          left: undefined,
-        }] as FeeDescriptionPair[])
-      }
-
-    });
-
-    test("should add both to the same row", (t) => {
-
-      const left = [{
         value: VALUES[1],
+        left: VALUES[1],
+        right: undefined,
+      },
+    ] as FeeDescriptionPair[]);
+  }
+  {
+    const pairs = createDenominationPairTimeline(right, left);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[1],
-      }] as FeeDescription[];
-
-      const right = [{
         value: VALUES[1],
+        right: VALUES[1],
+        left: undefined,
+      },
+    ] as FeeDescriptionPair[]);
+  }
+});
+
+test("should add both to the same row", (t) => {
+  const left = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[];
+
+  const right = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[];
+
+  {
+    const pairs = createDenominationPairTimeline(left, right);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[2],
-      }] as FeeDescription[];
-
-      {
-        const pairs = createDenominationPairTimeline(left, right)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: VALUES[2],
-        }] as FeeDescriptionPair[])
-      }
-      {
-        const pairs = createDenominationPairTimeline(right, left)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: VALUES[2],
-          right: VALUES[1],
-        }] as FeeDescriptionPair[])
-      }
-    });
-
-    test("should repeat the first and change the second", (t) => {
-
-      const left = [{
         value: VALUES[1],
+        left: VALUES[1],
+        right: VALUES[2],
+      },
+    ] as FeeDescriptionPair[]);
+  }
+  {
+    const pairs = createDenominationPairTimeline(right, left);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
-        until: ABS_TIME[5],
-        fee: VALUES[1],
-      }] as FeeDescription[];
-
-      const right = [{
+        until: ABS_TIME[3],
         value: VALUES[1],
+        left: VALUES[2],
+        right: VALUES[1],
+      },
+    ] as FeeDescriptionPair[]);
+  }
+});
+
+test("should repeat the first and change the second", (t) => {
+  const left = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[5],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[];
+
+  const right = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[2],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[3],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[3],
+      until: ABS_TIME[4],
+      fee: VALUES[3],
+    },
+  ] as FeeDescription[];
+
+  {
+    const pairs = createDenominationPairTimeline(left, right);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[2],
-        fee: VALUES[2],
-      }, {
         value: VALUES[1],
+        left: VALUES[1],
+        right: VALUES[2],
+      },
+      {
         from: ABS_TIME[2],
         until: ABS_TIME[3],
-      }, {
         value: VALUES[1],
+        left: VALUES[1],
+        right: undefined,
+      },
+      {
         from: ABS_TIME[3],
         until: ABS_TIME[4],
-        fee: VALUES[3],
-      }] as FeeDescription[];
-
-      {
-        const pairs = createDenominationPairTimeline(left, right)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[2],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: VALUES[2],
-        }, {
-          from: ABS_TIME[2],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: undefined,
-        }, {
-          from: ABS_TIME[3],
-          until: ABS_TIME[4],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: VALUES[3],
-        }, {
-          from: ABS_TIME[4],
-          until: ABS_TIME[5],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: undefined,
-        }] as FeeDescriptionPair[])
-      }
-
-
-    });
-
-  // })
-
-  // describe("multiple value example", (t) => {
-
-    test("should separate denominations of different value", (t) => {
-
-      const left = [{
         value: VALUES[1],
+        left: VALUES[1],
+        right: VALUES[3],
+      },
+      {
+        from: ABS_TIME[4],
+        until: ABS_TIME[5],
+        value: VALUES[1],
+        left: VALUES[1],
+        right: undefined,
+      },
+    ] as FeeDescriptionPair[]);
+  }
+});
+
+// })
+
+// describe("multiple value example", (t) => {
+
+test("should separate denominations of different value", (t) => {
+  const left = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[1],
+    },
+  ] as FeeDescription[];
+
+  const right = [
+    {
+      value: VALUES[2],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[];
+
+  {
+    const pairs = createDenominationPairTimeline(left, right);
+    expect(t, pairs).deep.equals([
+      {
+        from: ABS_TIME[1],
+        until: ABS_TIME[3],
+        value: VALUES[1],
+        left: VALUES[1],
+        right: undefined,
+      },
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[1],
-      }] as FeeDescription[];
-
-      const right = [{
         value: VALUES[2],
+        left: undefined,
+        right: VALUES[2],
+      },
+    ] as FeeDescriptionPair[]);
+  }
+  {
+    const pairs = createDenominationPairTimeline(right, left);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[2],
-      }] as FeeDescription[];
-
-      {
-        const pairs = createDenominationPairTimeline(left, right)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: undefined,
-        }, {
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[2],
-          left: undefined,
-          right: VALUES[2],
-        }] as FeeDescriptionPair[])
-      }
-      {
-        const pairs = createDenominationPairTimeline(right, left)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[1],
-          left: undefined,
-          right: VALUES[1],
-        }, {
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[2],
-          left: VALUES[2],
-          right: undefined,
-        }] as FeeDescriptionPair[])
-      }
-    });
-
-    test("should separate denominations of different value2", (t) => {
-
-      const left = [{
         value: VALUES[1],
+        left: undefined,
+        right: VALUES[1],
+      },
+      {
+        from: ABS_TIME[1],
+        until: ABS_TIME[3],
+        value: VALUES[2],
+        left: VALUES[2],
+        right: undefined,
+      },
+    ] as FeeDescriptionPair[]);
+  }
+});
+
+test("should separate denominations of different value2", (t) => {
+  const left = [
+    {
+      value: VALUES[1],
+      from: ABS_TIME[1],
+      until: ABS_TIME[2],
+      fee: VALUES[1],
+    },
+    {
+      value: VALUES[1],
+      from: ABS_TIME[2],
+      until: ABS_TIME[4],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[];
+
+  const right = [
+    {
+      value: VALUES[2],
+      from: ABS_TIME[1],
+      until: ABS_TIME[3],
+      fee: VALUES[2],
+    },
+  ] as FeeDescription[];
+
+  {
+    const pairs = createDenominationPairTimeline(left, right);
+    expect(t, pairs).deep.equals([
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[2],
-        fee: VALUES[1],
-      }, {
         value: VALUES[1],
+        left: VALUES[1],
+        right: undefined,
+      },
+      {
         from: ABS_TIME[2],
         until: ABS_TIME[4],
-        fee: VALUES[2],
-      }] as FeeDescription[];
-
-      const right = [{
-        value: VALUES[2],
+        value: VALUES[1],
+        left: VALUES[2],
+        right: undefined,
+      },
+      {
         from: ABS_TIME[1],
         until: ABS_TIME[3],
-        fee: VALUES[2],
-      }] as FeeDescription[];
-
-      {
-        const pairs = createDenominationPairTimeline(left, right)
-        expect(t,pairs).deep.equals([{
-          from: ABS_TIME[1],
-          until: ABS_TIME[2],
-          value: VALUES[1],
-          left: VALUES[1],
-          right: undefined,
-        }, {
-          from: ABS_TIME[2],
-          until: ABS_TIME[4],
-          value: VALUES[1],
-          left: VALUES[2],
-          right: undefined,
-        }, {
-          from: ABS_TIME[1],
-          until: ABS_TIME[3],
-          value: VALUES[2],
-          left: undefined,
-          right: VALUES[2],
-        }] as FeeDescriptionPair[])
-      }
-      // {
-      //   const pairs = createDenominationPairTimeline(right, left)
-      //   expect(t,pairs).deep.equals([{
-      //     from: moments[1],
-      //     until: moments[3],
-      //     value: values[1],
-      //     left: undefined,
-      //     right: values[1],
-      //   }, {
-      //     from: moments[1],
-      //     until: moments[3],
-      //     value: values[2],
-      //     left: values[2],
-      //     right: undefined,
-      //   }] as FeeDescriptionPair[])
-      // }
-    });
-    // it.skip("should render real world", (t) => {
-    //   const left = createDenominationTimeline(
-    //     bitcoinExchanges[0].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
-    //     "stampExpireDeposit", "feeDeposit");
-    //   const right = createDenominationTimeline(
-    //     bitcoinExchanges[1].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
-    //     "stampExpireDeposit", "feeDeposit");
-
-
-    //   const pairs = createDenominationPairTimeline(left, right)
-    // })
-    
-//   })
+        value: VALUES[2],
+        left: undefined,
+        right: VALUES[2],
+      },
+    ] as FeeDescriptionPair[]);
+  }
+  // {
+  //   const pairs = createDenominationPairTimeline(right, left)
+  //   expect(t,pairs).deep.equals([{
+  //     from: moments[1],
+  //     until: moments[3],
+  //     value: values[1],
+  //     left: undefined,
+  //     right: values[1],
+  //   }, {
+  //     from: moments[1],
+  //     until: moments[3],
+  //     value: values[2],
+  //     left: values[2],
+  //     right: undefined,
+  //   }] as FeeDescriptionPair[])
+  // }
+});
+// it.skip("should render real world", (t) => {
+//   const left = createDenominationTimeline(
+//     bitcoinExchanges[0].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
+//     "stampExpireDeposit", "feeDeposit");
+//   const right = createDenominationTimeline(
+//     bitcoinExchanges[1].denominations.filter(d => Amounts.cmp(d.value, Amounts.parseOrThrow('BITCOINBTC:0.01048576'))),
+//     "stampExpireDeposit", "feeDeposit");
+
+//   const pairs = createDenominationPairTimeline(left, right)
 // })
 
+//   })
+// })
diff --git a/packages/taler-wallet-core/src/util/denominations.ts b/packages/taler-wallet-core/src/util/denominations.ts
index cea940f48..4efb902c8 100644
--- a/packages/taler-wallet-core/src/util/denominations.ts
+++ b/packages/taler-wallet-core/src/util/denominations.ts
@@ -14,7 +14,16 @@
  GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
  */
 
-import { AbsoluteTime, AmountJson, Amounts, DenominationInfo, FeeDescription, FeeDescriptionPair, TalerProtocolTimestamp, TimePoint } from "@gnu-taler/taler-util";
+import {
+  AbsoluteTime,
+  AmountJson,
+  Amounts,
+  DenominationInfo,
+  FeeDescription,
+  FeeDescriptionPair,
+  TalerProtocolTimestamp,
+  TimePoint,
+} from "@gnu-taler/taler-util";
 
 /**
  * Given a list of denominations with the same value and same period of time:
@@ -52,14 +61,17 @@ type PropsWithReturnType<T extends object, F> = Exclude<
  * Takes two list and create one with one timeline.
  * For any element in the position "p" on the left or right "list", then
  * list[p].until should be equal to list[p+1].from
- * 
+ *
  * @see {createDenominationTimeline}
- * 
+ *
  * @param left list denominations @type {FeeDescription}
  * @param right list denominations @type {FeeDescription}
  * @returns list of pairs for the same time
  */
-export function createDenominationPairTimeline(left: FeeDescription[], right: FeeDescription[]): FeeDescriptionPair[] {
+export function createDenominationPairTimeline(
+  left: FeeDescription[],
+  right: FeeDescription[],
+): FeeDescriptionPair[] {
   //both list empty, discarded
   if (left.length === 0 && right.length === 0) return [];
 
@@ -69,31 +81,41 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
   let ri = 0;
 
   while (li < left.length && ri < right.length) {
-    const currentValue = Amounts.cmp(left[li].value, right[ri].value) < 0 ? left[li].value : right[ri].value;
-
-    let ll = 0 //left length (until next value)
-    while (li + ll < left.length && Amounts.cmp(left[li + ll].value, currentValue) === 0) {
-      ll++
+    const currentValue =
+      Amounts.cmp(left[li].value, right[ri].value) < 0
+        ? left[li].value
+        : right[ri].value;
+
+    let ll = 0; //left length (until next value)
+    while (
+      li + ll < left.length &&
+      Amounts.cmp(left[li + ll].value, currentValue) === 0
+    ) {
+      ll++;
     }
-    let rl = 0 //right length (until next value)
-    while (ri + rl < right.length && Amounts.cmp(right[ri + rl].value, currentValue) === 0) {
-      rl++
+    let rl = 0; //right length (until next value)
+    while (
+      ri + rl < right.length &&
+      Amounts.cmp(right[ri + rl].value, currentValue) === 0
+    ) {
+      rl++;
     }
-    const leftIsEmpty = ll === 0
-    const rightIsEmpty = rl === 0
+    const leftIsEmpty = ll === 0;
+    const rightIsEmpty = rl === 0;
     //check which start after, add gap so both list starts at the same time
     // one list may be empty
-    const leftStarts: AbsoluteTime =
-      leftIsEmpty ? { t_ms: "never" } : left[li].from;
-    const rightStarts: AbsoluteTime =
-      rightIsEmpty ? { t_ms: "never" } : right[ri].from;
+    const leftStarts: AbsoluteTime = leftIsEmpty
+      ? { t_ms: "never" }
+      : left[li].from;
+    const rightStarts: AbsoluteTime = rightIsEmpty
+      ? { t_ms: "never" }
+      : right[ri].from;
 
     //first time cut is the smallest time
     let timeCut: AbsoluteTime = leftStarts;
 
     if (AbsoluteTime.cmp(leftStarts, rightStarts) < 0) {
-      const ends =
-        rightIsEmpty ? left[li + ll - 1].until : right[0].from;
+      const ends = rightIsEmpty ? left[li + ll - 1].until : right[0].from;
 
       right.splice(ri, 0, {
         from: leftStarts,
@@ -102,11 +124,10 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
       });
       rl++;
 
-      timeCut = leftStarts
+      timeCut = leftStarts;
     }
     if (AbsoluteTime.cmp(leftStarts, rightStarts) > 0) {
-      const ends =
-        leftIsEmpty ? right[ri + rl - 1].until : left[0].from;
+      const ends = leftIsEmpty ? right[ri + rl - 1].until : left[0].from;
 
       left.splice(li, 0, {
         from: rightStarts,
@@ -115,7 +136,7 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
       });
       ll++;
 
-      timeCut = rightStarts
+      timeCut = rightStarts;
     }
 
     //check which ends sooner, add gap so both list ends at the same time
@@ -130,7 +151,6 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
         value: left[0].value,
       });
       rl++;
-
     }
     if (AbsoluteTime.cmp(leftEnds, rightEnds) < 0) {
       left.splice(li + ll, 0, {
@@ -142,15 +162,23 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
     }
 
     //now both lists are non empty and (starts,ends) at the same time
-    while (li < left.length && ri < right.length && Amounts.cmp(left[li].value, right[ri].value) === 0) {
-
-      if (AbsoluteTime.cmp(left[li].from, timeCut) !== 0 && AbsoluteTime.cmp(right[ri].from, timeCut) !== 0) {
+    while (
+      li < left.length &&
+      ri < right.length &&
+      Amounts.cmp(left[li].value, right[ri].value) === 0
+    ) {
+      if (
+        AbsoluteTime.cmp(left[li].from, timeCut) !== 0 &&
+        AbsoluteTime.cmp(right[ri].from, timeCut) !== 0
+      ) {
         // timeCut comes from the latest "until" (expiration from the previous)
         // and this value comes from the latest left or right
         // it should be the same as the "from" from one of the latest left or right
         // otherwise it means that there is missing a gap object in the middle
         // the list is not complete and the behavior is undefined
-        throw Error('one of the list is not completed: list[i].until !== list[i+1].from')
+        throw Error(
+          "one of the list is not completed: list[i].until !== list[i+1].from",
+        );
       }
 
       pairList.push({
@@ -172,21 +200,26 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
         timeCut = right[ri].until;
         ri++;
       }
-      pairList[pairList.length - 1].until = timeCut
+      pairList[pairList.length - 1].until = timeCut;
 
-      if (li < left.length && Amounts.cmp(left[li].value, pairList[pairList.length - 1].value) !== 0) {
+      if (
+        li < left.length &&
+        Amounts.cmp(left[li].value, pairList[pairList.length - 1].value) !== 0
+      ) {
         //value changed, should break
         //this if will catch when both (left and right) change at the same time
         //if just one side changed it will catch in the while condition
         break;
       }
-
     }
-
   }
   //one of the list left or right can still have elements
   if (li < left.length) {
-    let timeCut = pairList.length > 0 && Amounts.cmp(pairList[pairList.length - 1].value, left[li].value) === 0 ? pairList[pairList.length - 1].until : left[li].from;
+    let timeCut =
+      pairList.length > 0 &&
+      Amounts.cmp(pairList[pairList.length - 1].value, left[li].value) === 0
+        ? pairList[pairList.length - 1].until
+        : left[li].from;
     while (li < left.length) {
       pairList.push({
         left: left[li].fee,
@@ -194,13 +227,17 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
         from: timeCut,
         until: left[li].until,
         value: left[li].value,
-      })
-      timeCut = left[li].until
+      });
+      timeCut = left[li].until;
       li++;
     }
   }
   if (ri < right.length) {
-    let timeCut = pairList.length > 0 && Amounts.cmp(pairList[pairList.length - 1].value, right[ri].value) === 0 ? pairList[pairList.length - 1].until : right[ri].from;
+    let timeCut =
+      pairList.length > 0 &&
+      Amounts.cmp(pairList[pairList.length - 1].value, right[ri].value) === 0
+        ? pairList[pairList.length - 1].until
+        : right[ri].from;
     while (ri < right.length) {
       pairList.push({
         right: right[ri].fee,
@@ -208,12 +245,12 @@ export function createDenominationPairTimeline(left: FeeDescription[], right: Fe
         from: timeCut,
         until: right[ri].until,
         value: right[ri].value,
-      })
-      timeCut = right[ri].until
+      });
+      timeCut = right[ri].until;
       ri++;
     }
   }
-  return pairList
+  return pairList;
 }
 
 /**
diff --git a/packages/taler-wallet-core/src/util/retries.ts b/packages/taler-wallet-core/src/util/retries.ts
index 70b385c4a..b13e9a27b 100644
--- a/packages/taler-wallet-core/src/util/retries.ts
+++ b/packages/taler-wallet-core/src/util/retries.ts
@@ -243,7 +243,7 @@ export async function scheduleRetry(
   return await ws.db
     .mktx((x) => [x.operationRetries])
     .runReadWrite(async (tx) => {
-      tx.operationRetries
+      tx.operationRetries;
       scheduleRetryInTx(ws, tx, opId, errorDetail);
     });
 }
diff --git a/packages/taler-wallet-core/src/util/timer.ts b/packages/taler-wallet-core/src/util/timer.ts
index c850c663c..8ec1a25f8 100644
--- a/packages/taler-wallet-core/src/util/timer.ts
+++ b/packages/taler-wallet-core/src/util/timer.ts
@@ -42,7 +42,7 @@ export interface TimerHandle {
 }
 
 class IntervalHandle {
-  constructor(public h: any) { }
+  constructor(public h: any) {}
 
   clear(): void {
     clearInterval(this.h);
@@ -60,7 +60,7 @@ class IntervalHandle {
 }
 
 class TimeoutHandle {
-  constructor(public h: any) { }
+  constructor(public h: any) {}
 
   clear(): void {
     clearTimeout(this.h);
@@ -130,8 +130,6 @@ export class SetTimeoutTimerAPI implements TimerAPI {
   after(delayMs: number, callback: () => void): TimerHandle {
     return new TimeoutHandle(setTimeout(callback, delayMs));
   }
-
-
 }
 
 export const timer = new SetTimeoutTimerAPI();
@@ -146,7 +144,7 @@ export class TimerGroup {
 
   private idGen = 1;
 
-  constructor(public readonly timerApi: TimerAPI) { }
+  constructor(public readonly timerApi: TimerAPI) {}
 
   stopCurrentAndFutureTimers(): void {
     this.stopped = true;