pretty

1 files changed, 707 insertions, 601 deletions

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)
 // })
 
+//   })
+// })