npm - @ledgerhq/device-signer-kit-bitcoin - Versions diffs - 0.0.0-signer-eth-20250122093657 → 0.0.0-transaction-unfunded-20250917151052 - Mend

@ledgerhq/device-signer-kit-bitcoin 0.0.0-signer-eth-20250122093657 → 0.0.0-transaction-unfunded-20250917151052

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/lib/cjs/internal/data-store/model/DataStore.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/data-store/model/DataStore.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { Leaf } from \"@internal/merkle-tree/model/Leaf\";\nimport { type MerkleTree } from \"@internal/merkle-tree/model/MerkleTree\";\n\nimport { DataStore } from \"./DataStore\";\n\nconst SMALL_TREE = {\n  leaves: [\n    new Leaf(Uint8Array.from([0, 0]), Uint8Array.from([42])),\n    new Leaf(Uint8Array.from([0, 1]), Uint8Array.from([43])),\n    new Leaf(Uint8Array.from([0, 2]), Uint8Array.from([44])),\n    new Leaf(Uint8Array.from([0, 3]), Uint8Array.from([45])),\n  ],\n  proof: [Uint8Array.from([9, 8, 7, 6]), Uint8Array.from([5, 4, 3, 2])],\n  root: hexaStringToBuffer(\n    \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n  )!,\n};\n\nconst BIG_TREE = {\n  leaves: [\n    new Leaf(Uint8Array.from([1, 0]), Uint8Array.from([80])),\n    new Leaf(Uint8Array.from([2, 0]), Uint8Array.from([81])),\n    new Leaf(Uint8Array.from([3, 0]), Uint8Array.from([82])),\n    new Leaf(Uint8Array.from([4, 0]), Uint8Array.from([83])),\n    new Leaf(Uint8Array.from([5, 0]), Uint8Array.from([84])),\n    new Leaf(Uint8Array.from([6, 0]), Uint8Array.from([85])),\n    new Leaf(Uint8Array.from([7, 0]), Uint8Array.from([86])),\n    new Leaf(Uint8Array.from([8, 0]), Uint8Array.from([87])),\n    new Leaf(Uint8Array.from([9, 0]), Uint8Array.from([88])),\n    new Leaf(Uint8Array.from([10, 0]), Uint8Array.from([89])),\n  ],\n  proof: [\n    Uint8Array.from([0xff, 0xfe, 0xfd]),\n    Uint8Array.from([1, 2, 3, 4]),\n    Uint8Array.from([0xaa, 0xbb, 0xcc]),\n    Uint8Array.from([7, 6, 5, 4]),\n  ],\n  root: hexaStringToBuffer(\n    \"e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac\",\n  )!,\n};\n\ndescribe(\"DataStore\", () => {\n  // Mocked merkle tree\n  const createMerkletree = () => ({\n    size: jest.fn(),\n    getRoot: jest.fn(),\n    getLeaves: jest.fn(),\n    getLeafHash: jest.fn(),\n    getProof: jest.fn(),\n  });\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n  });\n\n  it(\"Add preimages, then get it\", () => {\n    // Given\n    const data1 = hexaStringToBuffer(\"deadbeef1\")!;\n    const data2 = hexaStringToBuffer(\"deadbeef2\")!;\n    const dataHash1 = hexaStringToBuffer(\"42ff1\")!;\n    const dataHash2 = hexaStringToBuffer(\"42ff2\")!;\n    const dataHash3 = hexaStringToBuffer(\"42ff3\")!;\n    const store = new DataStore();\n\n    // When\n    store.addPreimage(dataHash1, data1);\n    store.addPreimage(dataHash2, data2);\n\n    // Then\n    const preimage1 = store.getPreimage(dataHash1);\n    expect(preimage1.isJust()).toStrictEqual(true);\n    expect(preimage1.unsafeCoerce()).toStrictEqual(data1);\n    const preimage2 = store.getPreimage(dataHash2);\n    expect(preimage2.isJust()).toStrictEqual(true);\n    expect(preimage2.unsafeCoerce()).toStrictEqual(data2);\n    const preimage3 = store.getPreimage(dataHash3);\n    expect(preimage3.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Add merkletrees, then get index\", () => {\n    // Given\n    const invalidRoot = hexaStringToBuffer(\"deadbeef\")!;\n    const tree1 = createMerkletree();\n    const tree2 = createMerkletree();\n    const store = new DataStore();\n\n    // When\n    tree1.getRoot.mockReturnValueOnce(SMALL_TREE.root);\n    tree1.getLeaves\n      .mockReturnValueOnce(SMALL_TREE.leaves)\n      .mockReturnValueOnce(SMALL_TREE.leaves);\n    tree2.getRoot.mockReturnValueOnce(BIG_TREE.root);\n    tree2.getLeaves\n      .mockReturnValueOnce(BIG_TREE.leaves)\n      .mockReturnValueOnce(BIG_TREE.leaves)\n      .mockReturnValueOnce(BIG_TREE.leaves);\n\n    store.addMerkleTree(tree1 as unknown as MerkleTree);\n    store.addMerkleTree(tree2 as unknown as MerkleTree);\n\n    // Then\n    const index1 = store.getMerkleLeafIndex(\n      SMALL_TREE.root,\n      SMALL_TREE.leaves[2]!.hash,\n    );\n    expect(index1.isJust()).toStrictEqual(true);\n    expect(index1.unsafeCoerce()).toStrictEqual(2);\n    const index2 = store.getMerkleLeafIndex(\n      BIG_TREE.root,\n      BIG_TREE.leaves[7]!.hash,\n    );\n    expect(index2.isJust()).toStrictEqual(true);\n    expect(index2.unsafeCoerce()).toStrictEqual(7);\n    // hash not found in the tree\n    const index3 = store.getMerkleLeafIndex(\n      BIG_TREE.root,\n      SMALL_TREE.leaves[2]!.hash,\n    );\n    expect(index3.isJust()).toStrictEqual(false);\n    // root not found\n    const index4 = store.getMerkleLeafIndex(invalidRoot, invalidRoot);\n    expect(index4.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Add merkletrees, then get proof\", () => {\n    // Given\n    const invalidRoot = hexaStringToBuffer(\"deadbeef\")!;\n    const tree1 = createMerkletree();\n    const tree2 = createMerkletree();\n    const store = new DataStore();\n\n    // When\n    tree1.getRoot.mockReturnValueOnce(SMALL_TREE.root);\n    tree1.getLeaves.mockReturnValueOnce(SMALL_TREE.leaves);\n    tree1.getLeafHash.mockReturnValueOnce(Just(SMALL_TREE.leaves[1]!.hash));\n    tree1.getProof.mockReturnValueOnce(Just(SMALL_TREE.proof));\n    tree2.getRoot.mockReturnValueOnce(BIG_TREE.root);\n    tree2.getLeaves.mockReturnValueOnce(BIG_TREE.leaves);\n    tree2.getLeafHash\n      .mockReturnValueOnce(Just(BIG_TREE.leaves[5]!.hash))\n      .mockReturnValueOnce(Nothing)\n      .mockReturnValueOnce(Just(BIG_TREE.leaves[5]!.hash));\n    tree2.getProof\n      .mockReturnValueOnce(Just(BIG_TREE.proof))\n      .mockReturnValueOnce(Nothing);\n\n    store.addMerkleTree(tree1 as unknown as MerkleTree);\n    store.addMerkleTree(tree2 as unknown as MerkleTree);\n\n    // Then\n    const proof1 = store.getMerkleProof(SMALL_TREE.root, 1);\n    expect(proof1.isJust()).toStrictEqual(true);\n    expect(proof1.unsafeCoerce().leafHash).toStrictEqual(\n      SMALL_TREE.leaves[1]!.hash,\n    );\n    expect(proof1.unsafeCoerce().proof).toStrictEqual(SMALL_TREE.proof);\n    const proof2 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof2.isJust()).toStrictEqual(true);\n    expect(proof2.unsafeCoerce().leafHash).toStrictEqual(\n      BIG_TREE.leaves[5]!.hash,\n    );\n    expect(proof2.unsafeCoerce().proof).toStrictEqual(BIG_TREE.proof);\n    // getLeafHash returns Nothing\n    const proof3 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof3.isJust()).toStrictEqual(false);\n    // getProof returns Nothing\n    const proof4 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof4.isJust()).toStrictEqual(false);\n    // root not found\n    const proof5 = store.getMerkleProof(invalidRoot, 0);\n    expect(proof5.isJust()).toStrictEqual(false);\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { Leaf } from \"@internal/merkle-tree/model/Leaf\";\nimport { type MerkleTree } from \"@internal/merkle-tree/model/MerkleTree\";\n\nimport { DataStore } from \"./DataStore\";\n\nconst SMALL_TREE = {\n  leaves: [\n    new Leaf(Uint8Array.from([0, 0]), Uint8Array.from([42])),\n    new Leaf(Uint8Array.from([0, 1]), Uint8Array.from([43])),\n    new Leaf(Uint8Array.from([0, 2]), Uint8Array.from([44])),\n    new Leaf(Uint8Array.from([0, 3]), Uint8Array.from([45])),\n  ],\n  proof: [Uint8Array.from([9, 8, 7, 6]), Uint8Array.from([5, 4, 3, 2])],\n  root: hexaStringToBuffer(\n    \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n  )!,\n};\n\nconst BIG_TREE = {\n  leaves: [\n    new Leaf(Uint8Array.from([1, 0]), Uint8Array.from([80])),\n    new Leaf(Uint8Array.from([2, 0]), Uint8Array.from([81])),\n    new Leaf(Uint8Array.from([3, 0]), Uint8Array.from([82])),\n    new Leaf(Uint8Array.from([4, 0]), Uint8Array.from([83])),\n    new Leaf(Uint8Array.from([5, 0]), Uint8Array.from([84])),\n    new Leaf(Uint8Array.from([6, 0]), Uint8Array.from([85])),\n    new Leaf(Uint8Array.from([7, 0]), Uint8Array.from([86])),\n    new Leaf(Uint8Array.from([8, 0]), Uint8Array.from([87])),\n    new Leaf(Uint8Array.from([9, 0]), Uint8Array.from([88])),\n    new Leaf(Uint8Array.from([10, 0]), Uint8Array.from([89])),\n  ],\n  proof: [\n    Uint8Array.from([0xff, 0xfe, 0xfd]),\n    Uint8Array.from([1, 2, 3, 4]),\n    Uint8Array.from([0xaa, 0xbb, 0xcc]),\n    Uint8Array.from([7, 6, 5, 4]),\n  ],\n  root: hexaStringToBuffer(\n    \"e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac\",\n  )!,\n};\n\ndescribe(\"DataStore\", () => {\n  // Mocked merkle tree\n  const createMerkletree = () => ({\n    size: vi.fn(),\n    getRoot: vi.fn(),\n    getLeaves: vi.fn(),\n    getLeafHash: vi.fn(),\n    getProof: vi.fn(),\n  });\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n  });\n\n  it(\"Add preimages, then get it\", () => {\n    // Given\n    const data1 = hexaStringToBuffer(\"deadbeef1\")!;\n    const data2 = hexaStringToBuffer(\"deadbeef2\")!;\n    const dataHash1 = hexaStringToBuffer(\"42ff1\")!;\n    const dataHash2 = hexaStringToBuffer(\"42ff2\")!;\n    const dataHash3 = hexaStringToBuffer(\"42ff3\")!;\n    const store = new DataStore();\n\n    // When\n    store.addPreimage(dataHash1, data1);\n    store.addPreimage(dataHash2, data2);\n\n    // Then\n    const preimage1 = store.getPreimage(dataHash1);\n    expect(preimage1.isJust()).toStrictEqual(true);\n    expect(preimage1.unsafeCoerce()).toStrictEqual(data1);\n    const preimage2 = store.getPreimage(dataHash2);\n    expect(preimage2.isJust()).toStrictEqual(true);\n    expect(preimage2.unsafeCoerce()).toStrictEqual(data2);\n    const preimage3 = store.getPreimage(dataHash3);\n    expect(preimage3.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Add merkletrees, then get index\", () => {\n    // Given\n    const invalidRoot = hexaStringToBuffer(\"deadbeef\")!;\n    const tree1 = createMerkletree();\n    const tree2 = createMerkletree();\n    const store = new DataStore();\n\n    // When\n    tree1.getRoot.mockReturnValueOnce(SMALL_TREE.root);\n    tree1.getLeaves\n      .mockReturnValueOnce(SMALL_TREE.leaves)\n      .mockReturnValueOnce(SMALL_TREE.leaves);\n    tree2.getRoot.mockReturnValueOnce(BIG_TREE.root);\n    tree2.getLeaves\n      .mockReturnValueOnce(BIG_TREE.leaves)\n      .mockReturnValueOnce(BIG_TREE.leaves)\n      .mockReturnValueOnce(BIG_TREE.leaves);\n\n    store.addMerkleTree(tree1 as unknown as MerkleTree);\n    store.addMerkleTree(tree2 as unknown as MerkleTree);\n\n    // Then\n    const index1 = store.getMerkleLeafIndex(\n      SMALL_TREE.root,\n      SMALL_TREE.leaves[2]!.hash,\n    );\n    expect(index1.isJust()).toStrictEqual(true);\n    expect(index1.unsafeCoerce()).toStrictEqual(2);\n    const index2 = store.getMerkleLeafIndex(\n      BIG_TREE.root,\n      BIG_TREE.leaves[7]!.hash,\n    );\n    expect(index2.isJust()).toStrictEqual(true);\n    expect(index2.unsafeCoerce()).toStrictEqual(7);\n    // hash not found in the tree\n    const index3 = store.getMerkleLeafIndex(\n      BIG_TREE.root,\n      SMALL_TREE.leaves[2]!.hash,\n    );\n    expect(index3.isJust()).toStrictEqual(false);\n    // root not found\n    const index4 = store.getMerkleLeafIndex(invalidRoot, invalidRoot);\n    expect(index4.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Add merkletrees, then get proof\", () => {\n    // Given\n    const invalidRoot = hexaStringToBuffer(\"deadbeef\")!;\n    const tree1 = createMerkletree();\n    const tree2 = createMerkletree();\n    const store = new DataStore();\n\n    // When\n    tree1.getRoot.mockReturnValueOnce(SMALL_TREE.root);\n    tree1.getLeaves.mockReturnValueOnce(SMALL_TREE.leaves);\n    tree1.getLeafHash.mockReturnValueOnce(Just(SMALL_TREE.leaves[1]!.hash));\n    tree1.getProof.mockReturnValueOnce(Just(SMALL_TREE.proof));\n    tree2.getRoot.mockReturnValueOnce(BIG_TREE.root);\n    tree2.getLeaves.mockReturnValueOnce(BIG_TREE.leaves);\n    tree2.getLeafHash\n      .mockReturnValueOnce(Just(BIG_TREE.leaves[5]!.hash))\n      .mockReturnValueOnce(Nothing)\n      .mockReturnValueOnce(Just(BIG_TREE.leaves[5]!.hash));\n    tree2.getProof\n      .mockReturnValueOnce(Just(BIG_TREE.proof))\n      .mockReturnValueOnce(Nothing);\n\n    store.addMerkleTree(tree1 as unknown as MerkleTree);\n    store.addMerkleTree(tree2 as unknown as MerkleTree);\n\n    // Then\n    const proof1 = store.getMerkleProof(SMALL_TREE.root, 1);\n    expect(proof1.isJust()).toStrictEqual(true);\n    expect(proof1.unsafeCoerce().leafHash).toStrictEqual(\n      SMALL_TREE.leaves[1]!.hash,\n    );\n    expect(proof1.unsafeCoerce().proof).toStrictEqual(SMALL_TREE.proof);\n    const proof2 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof2.isJust()).toStrictEqual(true);\n    expect(proof2.unsafeCoerce().leafHash).toStrictEqual(\n      BIG_TREE.leaves[5]!.hash,\n    );\n    expect(proof2.unsafeCoerce().proof).toStrictEqual(BIG_TREE.proof);\n    // getLeafHash returns Nothing\n    const proof3 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof3.isJust()).toStrictEqual(false);\n    // getProof returns Nothing\n    const proof4 = store.getMerkleProof(BIG_TREE.root, 5);\n    expect(proof4.isJust()).toStrictEqual(false);\n    // root not found\n    const proof5 = store.getMerkleProof(invalidRoot, 0);\n    expect(proof5.isJust()).toStrictEqual(false);\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_device_management_kit", "import_purify_ts", "import_Leaf", "import_DataStore", "SMALL_TREE", "BIG_TREE", "createMerkletree", "data1", "data2", "dataHash1", "dataHash2", "dataHash3", "store", "preimage1", "preimage2", "preimage3", "invalidRoot", "tree1", "tree2", "index1", "index2", "index3", "index4", "proof1", "proof2", "proof3", "proof4", "proof5"]
 }

package/lib/cjs/internal/data-store/service/DefaultDataStoreService.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var o=require("purify-ts"),b=require("../../merkle-tree/model/Leaf"),h=require("../../merkle-tree/model/MerkleTree"),f=require("../../psbt/model/Psbt"),i=require("../../psbt/model/Value"),B=require("../../wallet/model/Wallet"),m=require("./DefaultDataStoreService");describe("DefaultDataStoreService",()=>{const a={build:jest.fn()},s={build:jest.fn()},w=jest.fn(),u={serialize:w,getId:jest.fn()},r={getPreimage:jest.fn(),getMerkleLeafIndex:jest.fn(),getMerkleProof:jest.fn(),addPreimage:jest.fn(),addMerkleTree:jest.fn(),addMerkleMap:jest.fn()},d=jest.fn(),k={hash:d};function c(e){return{getCommitment:()=>Uint8Array.from([e])}}function y(e){return{getRoot:()=>Uint8Array.from([e])}}describe("Merkleize chunks",()=>{beforeEach(()=>{jest.resetAllMocks()}),it("Success case",()=>{const e=[Uint8Array.from([0]),Uint8Array.from([2]),Uint8Array.from([3])],t=y(91),n=new m.DefaultDataStoreService(s,a,u,k);s.build.mockReturnValueOnce(t);const l=n.merklizeChunks(r,e);expect(s.build).toHaveBeenCalledWith(e),expect(r.addMerkleTree).toHaveBeenCalledWith(t),expect(l).toStrictEqual(Uint8Array.from([91]))})}),describe("Merkleize wallet",()=>{beforeEach(()=>{jest.resetAllMocks()}),it("Success case",()=>{const e=new h.MerkleTree(new b.Leaf(new Uint8Array,new Uint8Array(32).fill(7)),[]),t=new Uint8Array(5).fill(6),n=new Uint8Array(5).fill(7),l=new Uint8Array(5).fill(8),p=new B.Wallet({name:"Cold storage",descriptorTemplate:"template descriptor",keys:["key1","key2","key3"],hmac:new Uint8Array,keysTree:e,descriptorBuffer:new Uint8Array(32).fill(42)}),M=new m.DefaultDataStoreService(s,a,u,k);w.mockReturnValueOnce(t),d.mockReturnValueOnce(n).mockReturnValueOnce(l),M.merklizeWallet(r,p),expect(w).toHaveBeenCalledWith(p),expect(d).toHaveBeenCalledWith(t),expect(d).toHaveBeenCalledWith(p.descriptorBuffer),expect(r.addPreimage).toHaveBeenCalledWith(n,t),expect(r.addPreimage).toHaveBeenCalledWith(l,new Uint8Array(32).fill(42)),expect(r.addMerkleTree).toHaveBeenCalledWith(e)})}),describe("Merkleize a PSBT",()=>{const e={globalMap:new Map([["02",new i.Value(Uint8Array.from([2]))],["01",new i.Value(Uint8Array.from([1]))],["03",new i.Value(Uint8Array.from([3]))]]),inputMaps:[new Map([["09",new i.Value(Uint8Array.from([9]))],["01",new i.Value(Uint8Array.from([1]))],["07",new i.Value(Uint8Array.from([7]))]]),new Map([["07",new i.Value(Uint8Array.from([7]))],["03",new i.Value(Uint8Array.from([3]))],["01",new i.Value(Uint8Array.from([1]))]])],outputMaps:[new Map([["05",new i.Value(Uint8Array.from([5]))],["06",new i.Value(Uint8Array.from([6]))],["07",new i.Value(Uint8Array.from([7]))]])]};beforeEach(()=>{jest.resetAllMocks()}),it("Merkle map service failure",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,[],[]);a.build.mockReturnValueOnce((0,o.Left)(new Error));const l=t.merklizePsbt(r,n);expect(l.isRight()).toStrictEqual(!1)}),it("Merkle map service failure on inputs",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,[]);a.build.mockReturnValueOnce((0,o.Right)(c(42))).mockReturnValueOnce((0,o.Right)(c(43))).mockReturnValueOnce((0,o.Left)(new Error));const l=t.merklizePsbt(r,n);expect(l.isRight()).toStrictEqual(!1)}),it("Merkle map service failure on outputs",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValueOnce((0,o.Right)(c(42))).mockReturnValueOnce((0,o.Right)(c(43))).mockReturnValueOnce((0,o.Right)(c(44))).mockReturnValueOnce((0,o.Left)(new Error));const l=t.merklizePsbt(r,n);expect(l.isRight()).toStrictEqual(!1)}),it("Maps should be ordered",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValue((0,o.Left)(new Error)),t.merklizePsbt(r,n),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])],[Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([7]),Uint8Array.from([9])],[Uint8Array.from([1]),Uint8Array.from([7]),Uint8Array.from([9])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([3]),Uint8Array.from([7])],[Uint8Array.from([1]),Uint8Array.from([3]),Uint8Array.from([7])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7])],[Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7])])}),it("Success case",()=>{const t=c(42),n=c(43),l=c(44),p=c(45),M=y(91),A=y(92),S=new m.DefaultDataStoreService(s,a,u,k),v=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValueOnce((0,o.Right)(t)).mockReturnValueOnce((0,o.Right)(n)).mockReturnValueOnce((0,o.Right)(l)).mockReturnValueOnce((0,o.Right)(p)),s.build.mockReturnValueOnce(M).mockReturnValueOnce(A);const U=S.merklizePsbt(r,v);expect(r.addMerkleMap).toHaveBeenCalledWith(t),expect(r.addMerkleMap).toHaveBeenCalledWith(n),expect(r.addMerkleMap).toHaveBeenCalledWith(l),expect(r.addMerkleMap).toHaveBeenCalledWith(p),expect(r.addMerkleTree).toHaveBeenCalledWith(M),expect(r.addMerkleTree).toHaveBeenCalledWith(A),expect(s.build).toHaveBeenCalledWith([Uint8Array.from([43]),Uint8Array.from([44])]),expect(s.build).toHaveBeenCalledWith([Uint8Array.from([45])]),expect(U.isRight()).toStrictEqual(!0),expect(U.unsafeCoerce()).toStrictEqual({globalCommitment:Uint8Array.from([42]),inputsRoot:Uint8Array.from([91]),outputsRoot:Uint8Array.from([92])})})})});
+"use strict";var o=require("purify-ts"),v=require("../../merkle-tree/model/Leaf"),b=require("../../merkle-tree/model/MerkleTree"),f=require("../../psbt/model/Psbt"),l=require("../../psbt/model/Value"),h=require("../../wallet/model/Wallet"),m=require("./DefaultDataStoreService");describe("DefaultDataStoreService",()=>{const a={build:vi.fn()},s={build:vi.fn()},w=vi.fn(),u={serialize:w,getId:vi.fn()},r={getPreimage:vi.fn(),getMerkleLeafIndex:vi.fn(),getMerkleProof:vi.fn(),addPreimage:vi.fn(),addMerkleTree:vi.fn(),addMerkleMap:vi.fn()},d=vi.fn(),k={hash:d};function c(e){return{getCommitment:()=>Uint8Array.from([e])}}function y(e){return{getRoot:()=>Uint8Array.from([e])}}describe("Merkleize chunks",()=>{beforeEach(()=>{vi.resetAllMocks()}),it("Success case",()=>{const e=[Uint8Array.from([0]),Uint8Array.from([2]),Uint8Array.from([3])],t=y(91),n=new m.DefaultDataStoreService(s,a,u,k);s.build.mockReturnValueOnce(t);const i=n.merklizeChunks(r,e);expect(s.build).toHaveBeenCalledWith(e),expect(r.addMerkleTree).toHaveBeenCalledWith(t),expect(i).toStrictEqual(Uint8Array.from([91]))})}),describe("Merkleize wallet",()=>{beforeEach(()=>{vi.resetAllMocks()}),it("Success case",()=>{const e=new b.MerkleTree(new v.Leaf(new Uint8Array,new Uint8Array(32).fill(7)),[]),t=new Uint8Array(5).fill(6),n=new Uint8Array(5).fill(7),i=new Uint8Array(5).fill(8),p=new h.Wallet({name:"Cold storage",descriptorTemplate:"template descriptor",keys:["key1","key2","key3"],hmac:new Uint8Array,keysTree:e,descriptorBuffer:new Uint8Array(32).fill(42)}),M=new m.DefaultDataStoreService(s,a,u,k);w.mockReturnValueOnce(t),d.mockReturnValueOnce(n).mockReturnValueOnce(i),M.merklizeWallet(r,p),expect(w).toHaveBeenCalledWith(p),expect(d).toHaveBeenCalledWith(t),expect(d).toHaveBeenCalledWith(p.descriptorBuffer),expect(r.addPreimage).toHaveBeenCalledWith(n,t),expect(r.addPreimage).toHaveBeenCalledWith(i,new Uint8Array(32).fill(42)),expect(r.addMerkleTree).toHaveBeenCalledWith(e)})}),describe("Merkleize a PSBT",()=>{const e={globalMap:new Map([["02",new l.Value(Uint8Array.from([2]))],["01",new l.Value(Uint8Array.from([1]))],["03",new l.Value(Uint8Array.from([3]))]]),inputMaps:[new Map([["09",new l.Value(Uint8Array.from([9]))],["01",new l.Value(Uint8Array.from([1]))],["07",new l.Value(Uint8Array.from([7]))]]),new Map([["07",new l.Value(Uint8Array.from([7]))],["03",new l.Value(Uint8Array.from([3]))],["01",new l.Value(Uint8Array.from([1]))]])],outputMaps:[new Map([["05",new l.Value(Uint8Array.from([5]))],["06",new l.Value(Uint8Array.from([6]))],["07",new l.Value(Uint8Array.from([7]))]])]};beforeEach(()=>{vi.resetAllMocks()}),it("Merkle map service failure",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,[],[]);a.build.mockReturnValueOnce((0,o.Left)(new Error));const i=t.merklizePsbt(r,n);expect(i.isRight()).toStrictEqual(!1)}),it("Merkle map service failure on inputs",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,[]);a.build.mockReturnValueOnce((0,o.Right)(c(42))).mockReturnValueOnce((0,o.Right)(c(43))).mockReturnValueOnce((0,o.Left)(new Error));const i=t.merklizePsbt(r,n);expect(i.isRight()).toStrictEqual(!1)}),it("Merkle map service failure on outputs",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValueOnce((0,o.Right)(c(42))).mockReturnValueOnce((0,o.Right)(c(43))).mockReturnValueOnce((0,o.Right)(c(44))).mockReturnValueOnce((0,o.Left)(new Error));const i=t.merklizePsbt(r,n);expect(i.isRight()).toStrictEqual(!1)}),it("Maps should be ordered",()=>{const t=new m.DefaultDataStoreService(s,a,u,k),n=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValue((0,o.Left)(new Error)),t.merklizePsbt(r,n),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])],[Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([7]),Uint8Array.from([9])],[Uint8Array.from([1]),Uint8Array.from([7]),Uint8Array.from([9])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([1]),Uint8Array.from([3]),Uint8Array.from([7])],[Uint8Array.from([1]),Uint8Array.from([3]),Uint8Array.from([7])]),expect(a.build).toHaveBeenCalledWith([Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7])],[Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7])])}),it("Success case",()=>{const t=c(42),n=c(43),i=c(44),p=c(45),M=y(91),A=y(92),B=new m.DefaultDataStoreService(s,a,u,k),S=new f.Psbt(e.globalMap,e.inputMaps,e.outputMaps);a.build.mockReturnValueOnce((0,o.Right)(t)).mockReturnValueOnce((0,o.Right)(n)).mockReturnValueOnce((0,o.Right)(i)).mockReturnValueOnce((0,o.Right)(p)),s.build.mockReturnValueOnce(M).mockReturnValueOnce(A);const U=B.merklizePsbt(r,S);expect(r.addMerkleMap).toHaveBeenCalledWith(t),expect(r.addMerkleMap).toHaveBeenCalledWith(n),expect(r.addMerkleMap).toHaveBeenCalledWith(i),expect(r.addMerkleMap).toHaveBeenCalledWith(p),expect(r.addMerkleTree).toHaveBeenCalledWith(M),expect(r.addMerkleTree).toHaveBeenCalledWith(A),expect(s.build).toHaveBeenCalledWith([Uint8Array.from([43]),Uint8Array.from([44])]),expect(s.build).toHaveBeenCalledWith([Uint8Array.from([45])]),expect(U.isRight()).toStrictEqual(!0),expect(U.unsafeCoerce()).toStrictEqual({globalCommitment:Uint8Array.from([42]),inputsRoot:Uint8Array.from([91]),outputsRoot:Uint8Array.from([92])})})})});
 //# sourceMappingURL=DefaultDataStoreService.test.js.map

package/lib/cjs/internal/data-store/service/DefaultDataStoreService.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/data-store/service/DefaultDataStoreService.test.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { Leaf } from \"@internal/merkle-tree/model/Leaf\";\nimport { MerkleTree } from \"@internal/merkle-tree/model/MerkleTree\";\nimport { type HasherService } from \"@internal/merkle-tree/service/HasherService\";\nimport { type MerkleMapBuilder } from \"@internal/merkle-tree/service/MerkleMapBuilder\";\nimport { type MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\nimport { Psbt } from \"@internal/psbt/model/Psbt\";\nimport { Value } from \"@internal/psbt/model/Value\";\nimport { Wallet } from \"@internal/wallet/model/Wallet\";\nimport { type WalletSerializer } from \"@internal/wallet/service/WalletSerializer\";\n\nimport { DefaultDataStoreService } from \"./DefaultDataStoreService\";\n\ndescribe(\"DefaultDataStoreService\", () => {\n  const mockMerkleMapBuilder = {\n    build: jest.fn(),\n  };\n\n  const mockMerkleTreeBuilder = {\n    build: jest.fn(),\n  };\n\n  const mockWalletSerialize = jest.fn();\n  const mockWalletSerializer: WalletSerializer = {\n    serialize: mockWalletSerialize,\n    getId: jest.fn(),\n  };\n\n  const mockDataStore = {\n    getPreimage: jest.fn(),\n    getMerkleLeafIndex: jest.fn(),\n    getMerkleProof: jest.fn(),\n    addPreimage: jest.fn(),\n    addMerkleTree: jest.fn(),\n    addMerkleMap: jest.fn(),\n  };\n\n  const mockedHash = jest.fn();\n  const mockedHasherService: HasherService = {\n    hash: mockedHash,\n  };\n\n  function createMerkleMap(commitment: number) {\n    return {\n      getCommitment: () => Uint8Array.from([commitment]),\n    };\n  }\n\n  function createMerkleTree(root: number) {\n    return {\n      getRoot: () => Uint8Array.from([root]),\n    };\n  }\n\n  describe(\"Merkleize chunks\", () => {\n    beforeEach(() => {\n      jest.resetAllMocks();\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const chunks = [\n        Uint8Array.from([0]),\n        Uint8Array.from([2]),\n        Uint8Array.from([3]),\n      ];\n      const merkleTree = createMerkleTree(91);\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      mockMerkleTreeBuilder.build.mockReturnValueOnce(merkleTree);\n      const commitment = storeService.merklizeChunks(\n        mockDataStore as unknown as DataStore,\n        chunks,\n      );\n\n      // Then\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith(chunks);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree);\n      expect(commitment).toStrictEqual(Uint8Array.from([91]));\n    });\n  });\n\n  describe(\"Merkleize wallet\", () => {\n    beforeEach(() => {\n      jest.resetAllMocks();\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const merkleTree = new MerkleTree(\n        new Leaf(new Uint8Array(), new Uint8Array(32).fill(7)),\n        [],\n      );\n      const serialized = new Uint8Array(5).fill(6);\n      const hash1 = new Uint8Array(5).fill(7);\n      const hash2 = new Uint8Array(5).fill(8);\n      const wallet = new Wallet({\n        name: \"Cold storage\",\n        descriptorTemplate: \"template descriptor\",\n        keys: [\"key1\", \"key2\", \"key3\"],\n        hmac: new Uint8Array(),\n        keysTree: merkleTree,\n        descriptorBuffer: new Uint8Array(32).fill(42),\n      });\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      mockWalletSerialize.mockReturnValueOnce(serialized);\n      mockedHash.mockReturnValueOnce(hash1).mockReturnValueOnce(hash2);\n      storeService.merklizeWallet(\n        mockDataStore as unknown as DataStore,\n        wallet,\n      );\n\n      // Then\n      expect(mockWalletSerialize).toHaveBeenCalledWith(wallet);\n      expect(mockedHash).toHaveBeenCalledWith(serialized);\n      expect(mockedHash).toHaveBeenCalledWith(wallet.descriptorBuffer);\n      expect(mockDataStore.addPreimage).toHaveBeenCalledWith(hash1, serialized);\n      expect(mockDataStore.addPreimage).toHaveBeenCalledWith(\n        hash2,\n        new Uint8Array(32).fill(42),\n      );\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree);\n    });\n  });\n\n  describe(\"Merkleize a PSBT\", () => {\n    const TEST_PSBT = {\n      globalMap: new Map<string, Value>([\n        [\"02\", new Value(Uint8Array.from([2]))],\n        [\"01\", new Value(Uint8Array.from([1]))],\n        [\"03\", new Value(Uint8Array.from([3]))],\n      ]),\n      inputMaps: [\n        new Map<string, Value>([\n          [\"09\", new Value(Uint8Array.from([9]))],\n          [\"01\", new Value(Uint8Array.from([1]))],\n          [\"07\", new Value(Uint8Array.from([7]))],\n        ]),\n        new Map<string, Value>([\n          [\"07\", new Value(Uint8Array.from([7]))],\n          [\"03\", new Value(Uint8Array.from([3]))],\n          [\"01\", new Value(Uint8Array.from([1]))],\n        ]),\n      ],\n      outputMaps: [\n        new Map<string, Value>([\n          [\"05\", new Value(Uint8Array.from([5]))],\n          [\"06\", new Value(Uint8Array.from([6]))],\n          [\"07\", new Value(Uint8Array.from([7]))],\n        ]),\n      ],\n    };\n\n    beforeEach(() => {\n      jest.resetAllMocks();\n    });\n\n    it(\"Merkle map service failure\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(TEST_PSBT.globalMap, [], []);\n\n      // When\n      mockMerkleMapBuilder.build.mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Merkle map service failure on inputs\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(TEST_PSBT.globalMap, TEST_PSBT.inputMaps, []);\n\n      // When\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(createMerkleMap(42)))\n        .mockReturnValueOnce(Right(createMerkleMap(43)))\n        .mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Merkle map service failure on outputs\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(createMerkleMap(42)))\n        .mockReturnValueOnce(Right(createMerkleMap(43)))\n        .mockReturnValueOnce(Right(createMerkleMap(44)))\n        .mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Maps should be ordered\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n\n      // When\n      mockMerkleMapBuilder.build.mockReturnValue(Left(new Error()));\n      storeService.merklizePsbt(mockDataStore as unknown as DataStore, psbt);\n\n      // Then\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([2]), Uint8Array.from([3])],\n        [Uint8Array.from([1]), Uint8Array.from([2]), Uint8Array.from([3])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([7]), Uint8Array.from([9])],\n        [Uint8Array.from([1]), Uint8Array.from([7]), Uint8Array.from([9])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([3]), Uint8Array.from([7])],\n        [Uint8Array.from([1]), Uint8Array.from([3]), Uint8Array.from([7])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([5]), Uint8Array.from([6]), Uint8Array.from([7])],\n        [Uint8Array.from([5]), Uint8Array.from([6]), Uint8Array.from([7])],\n      );\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const merkleMap1 = createMerkleMap(42);\n      const merkleMap2 = createMerkleMap(43);\n      const merkleMap3 = createMerkleMap(44);\n      const merkleMap4 = createMerkleMap(45);\n      const merkleTree1 = createMerkleTree(91);\n      const merkleTree2 = createMerkleTree(92);\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n\n      // When\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(merkleMap1))\n        .mockReturnValueOnce(Right(merkleMap2))\n        .mockReturnValueOnce(Right(merkleMap3))\n        .mockReturnValueOnce(Right(merkleMap4));\n      mockMerkleTreeBuilder.build\n        .mockReturnValueOnce(merkleTree1)\n        .mockReturnValueOnce(merkleTree2);\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap1);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap2);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap3);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap4);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree1);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree2);\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith([\n        Uint8Array.from([43]),\n        Uint8Array.from([44]),\n      ]);\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith([\n        Uint8Array.from([45]),\n      ]);\n      expect(commitment.isRight()).toStrictEqual(true);\n      expect(commitment.unsafeCoerce()).toStrictEqual({\n        globalCommitment: Uint8Array.from([42]),\n        inputsRoot: Uint8Array.from([91]),\n        outputsRoot: Uint8Array.from([92]),\n      });\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { Leaf } from \"@internal/merkle-tree/model/Leaf\";\nimport { MerkleTree } from \"@internal/merkle-tree/model/MerkleTree\";\nimport { type HasherService } from \"@internal/merkle-tree/service/HasherService\";\nimport { type MerkleMapBuilder } from \"@internal/merkle-tree/service/MerkleMapBuilder\";\nimport { type MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\nimport { Psbt } from \"@internal/psbt/model/Psbt\";\nimport { Value } from \"@internal/psbt/model/Value\";\nimport { Wallet } from \"@internal/wallet/model/Wallet\";\nimport { type WalletSerializer } from \"@internal/wallet/service/WalletSerializer\";\n\nimport { DefaultDataStoreService } from \"./DefaultDataStoreService\";\n\ndescribe(\"DefaultDataStoreService\", () => {\n  const mockMerkleMapBuilder = {\n    build: vi.fn(),\n  };\n\n  const mockMerkleTreeBuilder = {\n    build: vi.fn(),\n  };\n\n  const mockWalletSerialize = vi.fn();\n  const mockWalletSerializer: WalletSerializer = {\n    serialize: mockWalletSerialize,\n    getId: vi.fn(),\n  };\n\n  const mockDataStore = {\n    getPreimage: vi.fn(),\n    getMerkleLeafIndex: vi.fn(),\n    getMerkleProof: vi.fn(),\n    addPreimage: vi.fn(),\n    addMerkleTree: vi.fn(),\n    addMerkleMap: vi.fn(),\n  };\n\n  const mockedHash = vi.fn();\n  const mockedHasherService: HasherService = {\n    hash: mockedHash,\n  };\n\n  function createMerkleMap(commitment: number) {\n    return {\n      getCommitment: () => Uint8Array.from([commitment]),\n    };\n  }\n\n  function createMerkleTree(root: number) {\n    return {\n      getRoot: () => Uint8Array.from([root]),\n    };\n  }\n\n  describe(\"Merkleize chunks\", () => {\n    beforeEach(() => {\n      vi.resetAllMocks();\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const chunks = [\n        Uint8Array.from([0]),\n        Uint8Array.from([2]),\n        Uint8Array.from([3]),\n      ];\n      const merkleTree = createMerkleTree(91);\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      mockMerkleTreeBuilder.build.mockReturnValueOnce(merkleTree);\n      const commitment = storeService.merklizeChunks(\n        mockDataStore as unknown as DataStore,\n        chunks,\n      );\n\n      // Then\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith(chunks);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree);\n      expect(commitment).toStrictEqual(Uint8Array.from([91]));\n    });\n  });\n\n  describe(\"Merkleize wallet\", () => {\n    beforeEach(() => {\n      vi.resetAllMocks();\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const merkleTree = new MerkleTree(\n        new Leaf(new Uint8Array(), new Uint8Array(32).fill(7)),\n        [],\n      );\n      const serialized = new Uint8Array(5).fill(6);\n      const hash1 = new Uint8Array(5).fill(7);\n      const hash2 = new Uint8Array(5).fill(8);\n      const wallet = new Wallet({\n        name: \"Cold storage\",\n        descriptorTemplate: \"template descriptor\",\n        keys: [\"key1\", \"key2\", \"key3\"],\n        hmac: new Uint8Array(),\n        keysTree: merkleTree,\n        descriptorBuffer: new Uint8Array(32).fill(42),\n      });\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      mockWalletSerialize.mockReturnValueOnce(serialized);\n      mockedHash.mockReturnValueOnce(hash1).mockReturnValueOnce(hash2);\n      storeService.merklizeWallet(\n        mockDataStore as unknown as DataStore,\n        wallet,\n      );\n\n      // Then\n      expect(mockWalletSerialize).toHaveBeenCalledWith(wallet);\n      expect(mockedHash).toHaveBeenCalledWith(serialized);\n      expect(mockedHash).toHaveBeenCalledWith(wallet.descriptorBuffer);\n      expect(mockDataStore.addPreimage).toHaveBeenCalledWith(hash1, serialized);\n      expect(mockDataStore.addPreimage).toHaveBeenCalledWith(\n        hash2,\n        new Uint8Array(32).fill(42),\n      );\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree);\n    });\n  });\n\n  describe(\"Merkleize a PSBT\", () => {\n    const TEST_PSBT = {\n      globalMap: new Map<string, Value>([\n        [\"02\", new Value(Uint8Array.from([2]))],\n        [\"01\", new Value(Uint8Array.from([1]))],\n        [\"03\", new Value(Uint8Array.from([3]))],\n      ]),\n      inputMaps: [\n        new Map<string, Value>([\n          [\"09\", new Value(Uint8Array.from([9]))],\n          [\"01\", new Value(Uint8Array.from([1]))],\n          [\"07\", new Value(Uint8Array.from([7]))],\n        ]),\n        new Map<string, Value>([\n          [\"07\", new Value(Uint8Array.from([7]))],\n          [\"03\", new Value(Uint8Array.from([3]))],\n          [\"01\", new Value(Uint8Array.from([1]))],\n        ]),\n      ],\n      outputMaps: [\n        new Map<string, Value>([\n          [\"05\", new Value(Uint8Array.from([5]))],\n          [\"06\", new Value(Uint8Array.from([6]))],\n          [\"07\", new Value(Uint8Array.from([7]))],\n        ]),\n      ],\n    };\n\n    beforeEach(() => {\n      vi.resetAllMocks();\n    });\n\n    it(\"Merkle map service failure\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(TEST_PSBT.globalMap, [], []);\n\n      // When\n      mockMerkleMapBuilder.build.mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Merkle map service failure on inputs\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(TEST_PSBT.globalMap, TEST_PSBT.inputMaps, []);\n\n      // When\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(createMerkleMap(42)))\n        .mockReturnValueOnce(Right(createMerkleMap(43)))\n        .mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Merkle map service failure on outputs\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n\n      // When\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(createMerkleMap(42)))\n        .mockReturnValueOnce(Right(createMerkleMap(43)))\n        .mockReturnValueOnce(Right(createMerkleMap(44)))\n        .mockReturnValueOnce(Left(new Error()));\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(commitment.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Maps should be ordered\", () => {\n      // Given\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n\n      // When\n      mockMerkleMapBuilder.build.mockReturnValue(Left(new Error()));\n      storeService.merklizePsbt(mockDataStore as unknown as DataStore, psbt);\n\n      // Then\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([2]), Uint8Array.from([3])],\n        [Uint8Array.from([1]), Uint8Array.from([2]), Uint8Array.from([3])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([7]), Uint8Array.from([9])],\n        [Uint8Array.from([1]), Uint8Array.from([7]), Uint8Array.from([9])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([1]), Uint8Array.from([3]), Uint8Array.from([7])],\n        [Uint8Array.from([1]), Uint8Array.from([3]), Uint8Array.from([7])],\n      );\n      expect(mockMerkleMapBuilder.build).toHaveBeenCalledWith(\n        [Uint8Array.from([5]), Uint8Array.from([6]), Uint8Array.from([7])],\n        [Uint8Array.from([5]), Uint8Array.from([6]), Uint8Array.from([7])],\n      );\n    });\n\n    it(\"Success case\", () => {\n      // Given\n      const merkleMap1 = createMerkleMap(42);\n      const merkleMap2 = createMerkleMap(43);\n      const merkleMap3 = createMerkleMap(44);\n      const merkleMap4 = createMerkleMap(45);\n      const merkleTree1 = createMerkleTree(91);\n      const merkleTree2 = createMerkleTree(92);\n      const storeService = new DefaultDataStoreService(\n        mockMerkleTreeBuilder as unknown as MerkleTreeBuilder,\n        mockMerkleMapBuilder as unknown as MerkleMapBuilder,\n        mockWalletSerializer,\n        mockedHasherService,\n      );\n      const psbt = new Psbt(\n        TEST_PSBT.globalMap,\n        TEST_PSBT.inputMaps,\n        TEST_PSBT.outputMaps,\n      );\n\n      // When\n      mockMerkleMapBuilder.build\n        .mockReturnValueOnce(Right(merkleMap1))\n        .mockReturnValueOnce(Right(merkleMap2))\n        .mockReturnValueOnce(Right(merkleMap3))\n        .mockReturnValueOnce(Right(merkleMap4));\n      mockMerkleTreeBuilder.build\n        .mockReturnValueOnce(merkleTree1)\n        .mockReturnValueOnce(merkleTree2);\n      const commitment = storeService.merklizePsbt(\n        mockDataStore as unknown as DataStore,\n        psbt,\n      );\n\n      // Then\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap1);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap2);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap3);\n      expect(mockDataStore.addMerkleMap).toHaveBeenCalledWith(merkleMap4);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree1);\n      expect(mockDataStore.addMerkleTree).toHaveBeenCalledWith(merkleTree2);\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith([\n        Uint8Array.from([43]),\n        Uint8Array.from([44]),\n      ]);\n      expect(mockMerkleTreeBuilder.build).toHaveBeenCalledWith([\n        Uint8Array.from([45]),\n      ]);\n      expect(commitment.isRight()).toStrictEqual(true);\n      expect(commitment.unsafeCoerce()).toStrictEqual({\n        globalCommitment: Uint8Array.from([42]),\n        inputsRoot: Uint8Array.from([91]),\n        outputsRoot: Uint8Array.from([92]),\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_purify_ts", "import_Leaf", "import_MerkleTree", "import_Psbt", "import_Value", "import_Wallet", "import_DefaultDataStoreService", "mockMerkleMapBuilder", "mockMerkleTreeBuilder", "mockWalletSerialize", "mockWalletSerializer", "mockDataStore", "mockedHash", "mockedHasherService", "createMerkleMap", "commitment", "createMerkleTree", "root", "chunks", "merkleTree", "storeService", "serialized", "hash1", "hash2", "wallet", "TEST_PSBT", "psbt", "merkleMap1", "merkleMap2", "merkleMap3", "merkleMap4", "merkleTree1", "merkleTree2"]
 }

package/lib/cjs/internal/di.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var n=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var C=(o,e)=>{for(var t in e)n(o,t,{get:e[t],enumerable:!0})},D=(o,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of y(e))!f.call(o,r)&&r!==t&&n(o,r,{get:()=>e[r],enumerable:!(i=u(e,r))||i.enumerable});return o};var k=o=>D(n({},"__esModule",{value:!0}),o);var F={};C(F,{makeContainer:()=>v});module.exports=k(F);var m=require("inversify"),s=require("./data-store/di/dataStoreModule"),a=require("./externalTypes"),p=require("./merkle-tree/di/merkleTreeModule"),d=require("./psbt/di/psbtModule"),c=require("./use-cases/di/useCasesModule"),l=require("./wallet/di/walletModule"),M=require("./app-binder/di/appBinderModule");const v=({dmk:o,sessionId:e})=>{const t=new m.Container;return t.bind(a.externalTypes.Dmk).toConstantValue(o),t.bind(a.externalTypes.SessionId).toConstantValue(e),t.load((0,M.appBinderModuleFactory)(),(0,c.useCasesModuleFactory)(),(0,l.walletModuleFactory)(),(0,d.psbtModuleFactory)(),(0,s.dataStoreModuleFactory)(),(0,p.merkleTreeModuleFactory)()),t};0&&(module.exports={makeContainer});
+"use strict";var n=Object.defineProperty;var M=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var C=(o,e)=>{for(var t in e)n(o,t,{get:e[t],enumerable:!0})},D=(o,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of u(e))!f.call(o,r)&&r!==t&&n(o,r,{get:()=>e[r],enumerable:!(i=M(e,r))||i.enumerable});return o};var k=o=>D(n({},"__esModule",{value:!0}),o);var F={};C(F,{makeContainer:()=>v});module.exports=k(F);var m=require("inversify"),s=require("./data-store/di/dataStoreModule"),a=require("./externalTypes"),p=require("./merkle-tree/di/merkleTreeModule"),d=require("./psbt/di/psbtModule"),c=require("./use-cases/di/useCasesModule"),l=require("./wallet/di/walletModule"),y=require("./app-binder/di/appBinderModule");const v=({dmk:o,sessionId:e})=>{const t=new m.Container;return t.bind(a.externalTypes.Dmk).toConstantValue(o),t.bind(a.externalTypes.SessionId).toConstantValue(e),t.loadSync((0,y.appBinderModuleFactory)(),(0,c.useCasesModuleFactory)(),(0,l.walletModuleFactory)(),(0,d.psbtModuleFactory)(),(0,s.dataStoreModuleFactory)(),(0,p.merkleTreeModuleFactory)()),t};0&&(module.exports={makeContainer});
 //# sourceMappingURL=di.js.map

package/lib/cjs/internal/di.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/di.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { Container } from \"inversify\";\n\nimport { dataStoreModuleFactory } from \"@internal/data-store/di/dataStoreModule\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { merkleTreeModuleFactory } from \"@internal/merkle-tree/di/merkleTreeModule\";\nimport { psbtModuleFactory } from \"@internal/psbt/di/psbtModule\";\nimport { useCasesModuleFactory } from \"@internal/use-cases/di/useCasesModule\";\nimport { walletModuleFactory } from \"@internal/wallet/di/walletModule\";\n\nimport { appBinderModuleFactory } from \"./app-binder/di/appBinderModule\";\n\ntype MakeContainerProps = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n};\nexport const makeContainer = ({ dmk, sessionId }: MakeContainerProps) => {\n  const container = new Container();\n\n  container.bind<DeviceManagementKit>(externalTypes.Dmk).toConstantValue(dmk);\n  container\n    .bind<DeviceSessionId>(externalTypes.SessionId)\n    .toConstantValue(sessionId);\n\n  container.load(\n    appBinderModuleFactory(),\n    useCasesModuleFactory(),\n    walletModuleFactory(),\n    psbtModuleFactory(),\n    dataStoreModuleFactory(),\n    merkleTreeModuleFactory(),\n  );\n\n  return container;\n};\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mBAAAE,IAAA,eAAAC,EAAAH,GAIA,IAAAI,EAA0B,qBAE1BC,EAAuC,mDACvCC,EAA8B,mCAC9BC,EAAwC,qDACxCC,EAAkC,wCAClCC,EAAsC,iDACtCC,EAAoC,4CAEpCC,EAAuC,2CAMhC,MAAMT,EAAgB,CAAC,CAAE,IAAAU,EAAK,UAAAC,CAAU,IAA0B,CACvE,MAAMC,EAAY,IAAI,YAEtB,OAAAA,EAAU,KAA0B,gBAAc,GAAG,EAAE,gBAAgBF,CAAG,EAC1EE,EACG,KAAsB,gBAAc,SAAS,EAC7C,gBAAgBD,CAAS,EAE5BC,EAAU,QACR,0BAAuB,KACvB,yBAAsB,KACtB,uBAAoB,KACpB,qBAAkB,KAClB,0BAAuB,KACvB,2BAAwB,CAC1B,EAEOA,CACT",
+  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { Container } from \"inversify\";\n\nimport { dataStoreModuleFactory } from \"@internal/data-store/di/dataStoreModule\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { merkleTreeModuleFactory } from \"@internal/merkle-tree/di/merkleTreeModule\";\nimport { psbtModuleFactory } from \"@internal/psbt/di/psbtModule\";\nimport { useCasesModuleFactory } from \"@internal/use-cases/di/useCasesModule\";\nimport { walletModuleFactory } from \"@internal/wallet/di/walletModule\";\n\nimport { appBinderModuleFactory } from \"./app-binder/di/appBinderModule\";\n\ntype MakeContainerProps = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n};\nexport const makeContainer = ({ dmk, sessionId }: MakeContainerProps) => {\n  const container = new Container();\n\n  container.bind<DeviceManagementKit>(externalTypes.Dmk).toConstantValue(dmk);\n  container\n    .bind<DeviceSessionId>(externalTypes.SessionId)\n    .toConstantValue(sessionId);\n\n  container.loadSync(\n    appBinderModuleFactory(),\n    useCasesModuleFactory(),\n    walletModuleFactory(),\n    psbtModuleFactory(),\n    dataStoreModuleFactory(),\n    merkleTreeModuleFactory(),\n  );\n\n  return container;\n};\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mBAAAE,IAAA,eAAAC,EAAAH,GAIA,IAAAI,EAA0B,qBAE1BC,EAAuC,mDACvCC,EAA8B,mCAC9BC,EAAwC,qDACxCC,EAAkC,wCAClCC,EAAsC,iDACtCC,EAAoC,4CAEpCC,EAAuC,2CAMhC,MAAMT,EAAgB,CAAC,CAAE,IAAAU,EAAK,UAAAC,CAAU,IAA0B,CACvE,MAAMC,EAAY,IAAI,YAEtB,OAAAA,EAAU,KAA0B,gBAAc,GAAG,EAAE,gBAAgBF,CAAG,EAC1EE,EACG,KAAsB,gBAAc,SAAS,EAC7C,gBAAgBD,CAAS,EAE5BC,EAAU,YACR,0BAAuB,KACvB,yBAAsB,KACtB,uBAAoB,KACpB,qBAAkB,KAClB,0BAAuB,KACvB,2BAAwB,CAC1B,EAEOA,CACT",
   "names": ["di_exports", "__export", "makeContainer", "__toCommonJS", "import_inversify", "import_dataStoreModule", "import_externalTypes", "import_merkleTreeModule", "import_psbtModule", "import_useCasesModule", "import_walletModule", "import_appBinderModule", "dmk", "sessionId", "container"]
 }

package/lib/cjs/internal/merkle-tree/di/merkleTreeModule.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var l=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var M=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var k=(e,r)=>{for(var i in r)l(e,i,{get:r[i],enumerable:!0})},s=(e,r,i,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of M(r))!c.call(e,o)&&o!==i&&l(e,o,{get:()=>r[o],enumerable:!(n=d(r,o))||n.enumerable});return e};var _=e=>s(l({},"__esModule",{value:!0}),e);var B={};k(B,{merkleTreeModuleFactory:()=>f});module.exports=_(B);var m=require("inversify"),t=require("../../merkle-tree/di/merkleTreeTypes"),a=require("../../merkle-tree/service/MerkleMapBuilder"),p=require("../../merkle-tree/service/MerkleTreeBuilder"),u=require("../../merkle-tree/service/Sha256HasherService");const f=()=>new m.ContainerModule((e,r,i,n,o,T,v)=>{e(t.merkleTreeTypes.HasherService).to(u.Sha256HasherService),e(t.merkleTreeTypes.MerkleTreeBuilder).to(p.MerkleTreeBuilder),e(t.merkleTreeTypes.MerkleMapBuilder).to(a.MerkleMapBuilder)});0&&(module.exports={merkleTreeModuleFactory});
+"use strict";var t=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var c=(e,r)=>{for(var l in r)t(e,l,{get:r[l],enumerable:!0})},d=(e,r,l,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of f(r))!T.call(e,o)&&o!==l&&t(e,o,{get:()=>r[o],enumerable:!(i=u(r,o))||i.enumerable});return e};var s=e=>d(t({},"__esModule",{value:!0}),e);var h={};c(h,{merkleTreeModuleFactory:()=>B});module.exports=s(h);var p=require("inversify"),m=require("../../merkle-tree/di/merkleTreeTypes"),M=require("../../merkle-tree/service/MerkleMapBuilder"),a=require("../../merkle-tree/service/MerkleTreeBuilder"),k=require("../../merkle-tree/service/Sha256HasherService");const B=()=>new p.ContainerModule(({bind:e})=>{e(m.merkleTreeTypes.HasherService).to(k.Sha256HasherService),e(m.merkleTreeTypes.MerkleTreeBuilder).to(a.MerkleTreeBuilder),e(m.merkleTreeTypes.MerkleMapBuilder).to(M.MerkleMapBuilder)});0&&(module.exports={merkleTreeModuleFactory});
 //# sourceMappingURL=merkleTreeModule.js.map

package/lib/cjs/internal/merkle-tree/di/merkleTreeModule.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/merkle-tree/di/merkleTreeModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { merkleTreeTypes } from \"@internal/merkle-tree/di/merkleTreeTypes\";\nimport { MerkleMapBuilder } from \"@internal/merkle-tree/service/MerkleMapBuilder\";\nimport { MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\nimport { Sha256HasherService } from \"@internal/merkle-tree/service/Sha256HasherService\";\n\nexport const merkleTreeModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(merkleTreeTypes.HasherService).to(Sha256HasherService);\n      bind(merkleTreeTypes.MerkleTreeBuilder).to(MerkleTreeBuilder);\n      bind(merkleTreeTypes.MerkleMapBuilder).to(MerkleMapBuilder);\n    },\n  );\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,6BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAAgC,oDAChCC,EAAiC,0DACjCC,EAAkC,2DAClCC,EAAoC,6DAE7B,MAAMN,EAA0B,IACrC,IAAI,kBACF,CACEO,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAK,kBAAgB,aAAa,EAAE,GAAG,qBAAmB,EAC1DA,EAAK,kBAAgB,iBAAiB,EAAE,GAAG,mBAAiB,EAC5DA,EAAK,kBAAgB,gBAAgB,EAAE,GAAG,kBAAgB,CAC5D,CACF",
-  "names": ["merkleTreeModule_exports", "__export", "merkleTreeModuleFactory", "__toCommonJS", "import_inversify", "import_merkleTreeTypes", "import_MerkleMapBuilder", "import_MerkleTreeBuilder", "import_Sha256HasherService", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { merkleTreeTypes } from \"@internal/merkle-tree/di/merkleTreeTypes\";\nimport { MerkleMapBuilder } from \"@internal/merkle-tree/service/MerkleMapBuilder\";\nimport { MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\nimport { Sha256HasherService } from \"@internal/merkle-tree/service/Sha256HasherService\";\n\nexport const merkleTreeModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(merkleTreeTypes.HasherService).to(Sha256HasherService);\n    bind(merkleTreeTypes.MerkleTreeBuilder).to(MerkleTreeBuilder);\n    bind(merkleTreeTypes.MerkleMapBuilder).to(MerkleMapBuilder);\n  });\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,6BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAAgC,oDAChCC,EAAiC,0DACjCC,EAAkC,2DAClCC,EAAoC,6DAE7B,MAAMN,EAA0B,IACrC,IAAI,kBAAgB,CAAC,CAAE,KAAAO,CAAK,IAAM,CAChCA,EAAK,kBAAgB,aAAa,EAAE,GAAG,qBAAmB,EAC1DA,EAAK,kBAAgB,iBAAiB,EAAE,GAAG,mBAAiB,EAC5DA,EAAK,kBAAgB,gBAAgB,EAAE,GAAG,kBAAgB,CAC5D,CAAC",
+  "names": ["merkleTreeModule_exports", "__export", "merkleTreeModuleFactory", "__toCommonJS", "import_inversify", "import_merkleTreeTypes", "import_MerkleMapBuilder", "import_MerkleTreeBuilder", "import_Sha256HasherService", "bind"]
 }

package/lib/cjs/internal/merkle-tree/di/merkleTreeModule.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var o=require("inversify"),t=require("./merkleTreeModule");describe("MerkleTreeModuleFactory",()=>{describe("Default",()=>{let r,e;beforeEach(()=>{e=(0,t.merkleTreeModuleFactory)(),r=new o.Container,r.load(e)}),it("should return the merkle tree service module",()=>{expect(e).toBeDefined()})})});
+"use strict";var o=require("inversify"),t=require("./merkleTreeModule");describe("MerkleTreeModuleFactory",()=>{describe("Default",()=>{let r,e;beforeEach(()=>{e=(0,t.merkleTreeModuleFactory)(),r=new o.Container,r.loadSync(e)}),it("should return the merkle tree service module",()=>{expect(e).toBeDefined()})})});
 //# sourceMappingURL=merkleTreeModule.test.js.map

package/lib/cjs/internal/merkle-tree/di/merkleTreeModule.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/merkle-tree/di/merkleTreeModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { merkleTreeModuleFactory } from \"./merkleTreeModule\";\n\ndescribe(\"MerkleTreeModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof merkleTreeModuleFactory>;\n    beforeEach(() => {\n      mod = merkleTreeModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the merkle tree service module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAwC,8BAExC,SAAS,0BAA2B,IAAM,CACxC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,2BAAwB,EAC9BD,EAAY,IAAI,YAChBA,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,+CAAgD,IAAM,CACvD,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { merkleTreeModuleFactory } from \"./merkleTreeModule\";\n\ndescribe(\"MerkleTreeModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof merkleTreeModuleFactory>;\n    beforeEach(() => {\n      mod = merkleTreeModuleFactory();\n      container = new Container();\n      container.loadSync(mod);\n    });\n\n    it(\"should return the merkle tree service module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAwC,8BAExC,SAAS,0BAA2B,IAAM,CACxC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,2BAAwB,EAC9BD,EAAY,IAAI,YAChBA,EAAU,SAASC,CAAG,CACxB,CAAC,EAED,GAAG,+CAAgD,IAAM,CACvD,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_inversify", "import_merkleTreeModule", "container", "mod"]
 }

package/lib/cjs/internal/merkle-tree/service/MerkleMapBuilder.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var a=require("./MerkleMapBuilder");describe("MerkleMapBuilder",()=>{const r=[Uint8Array.from([0,1,2,3]),Uint8Array.from([0,1,2,4]),Uint8Array.from([0,1,2,5]),Uint8Array.from([0,2,2,3]),Uint8Array.from([1,1,2,3])],t=[Uint8Array.from([0,0]),Uint8Array.from([255,255,255,255]),Uint8Array.from([0,1,2,5]),Uint8Array.from([0,255]),Uint8Array.from([254,57])],o=jest.fn(),l={build:o};let i;beforeEach(()=>{jest.resetAllMocks(),i=new a.MerkleMapBuilder(l)}),it("Invalid value count",()=>{const e=i.build(r,[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("Invalid ordering",()=>{const e=i.build([Uint8Array.from([0,1,2,5]),...r],[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("Dupplicate key",()=>{const e=i.build([Uint8Array.from([0,1,2,3]),...r],[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("correct value",()=>{o.mockReturnValueOnce({getRoot:()=>Uint8Array.from([42,43]),size:()=>r.length}).mockReturnValueOnce({getRoot:()=>Uint8Array.from([44,45]),size:()=>t.length});const e=i.build(r,t);expect(e.isRight()).toStrictEqual(!0),expect(o).toHaveBeenCalledWith(r),expect(o).toHaveBeenCalledWith(t)})});
+"use strict";var a=require("./MerkleMapBuilder");describe("MerkleMapBuilder",()=>{const r=[Uint8Array.from([0,1,2,3]),Uint8Array.from([0,1,2,4]),Uint8Array.from([0,1,2,5]),Uint8Array.from([0,2,2,3]),Uint8Array.from([1,1,2,3])],t=[Uint8Array.from([0,0]),Uint8Array.from([255,255,255,255]),Uint8Array.from([0,1,2,5]),Uint8Array.from([0,255]),Uint8Array.from([254,57])],o=vi.fn(),l={build:o};let i;beforeEach(()=>{vi.resetAllMocks(),i=new a.MerkleMapBuilder(l)}),it("Invalid value count",()=>{const e=i.build(r,[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("Invalid ordering",()=>{const e=i.build([Uint8Array.from([0,1,2,5]),...r],[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("Dupplicate key",()=>{const e=i.build([Uint8Array.from([0,1,2,3]),...r],[Uint8Array.from([0]),...t]);expect(e.isRight()).toStrictEqual(!1)}),it("correct value",()=>{o.mockReturnValueOnce({getRoot:()=>Uint8Array.from([42,43]),size:()=>r.length}).mockReturnValueOnce({getRoot:()=>Uint8Array.from([44,45]),size:()=>t.length});const e=i.build(r,t);expect(e.isRight()).toStrictEqual(!0),expect(o).toHaveBeenCalledWith(r),expect(o).toHaveBeenCalledWith(t)})});
 //# sourceMappingURL=MerkleMapBuilder.test.js.map

package/lib/cjs/internal/merkle-tree/service/MerkleMapBuilder.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/merkle-tree/service/MerkleMapBuilder.test.ts"],
-  "sourcesContent": ["import { type MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\n\nimport { MerkleMapBuilder } from \"./MerkleMapBuilder\";\n\ndescribe(\"MerkleMapBuilder\", () => {\n  const TEST_KEYS = [\n    Uint8Array.from([0, 1, 2, 3]),\n    Uint8Array.from([0, 1, 2, 4]),\n    Uint8Array.from([0, 1, 2, 5]),\n    Uint8Array.from([0, 2, 2, 3]),\n    Uint8Array.from([1, 1, 2, 3]),\n  ];\n\n  const TEST_VALUES = [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0xff, 0xff, 0xff, 0xff]),\n    Uint8Array.from([0, 1, 2, 5]),\n    Uint8Array.from([0, 0xff]),\n    Uint8Array.from([0xfe, 57]),\n  ];\n\n  const mockCreateMerkleTree = jest.fn();\n  const mockMerkleTree: MerkleTreeBuilder = {\n    build: mockCreateMerkleTree,\n  } as unknown as MerkleTreeBuilder;\n  let builder: MerkleMapBuilder;\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n    builder = new MerkleMapBuilder(mockMerkleTree);\n  });\n\n  it(\"Invalid value count\", () => {\n    const eitherMap = builder.build(TEST_KEYS, [\n      Uint8Array.from([0]),\n      ...TEST_VALUES,\n    ]);\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"Invalid ordering\", () => {\n    const eitherMap = builder.build(\n      [Uint8Array.from([0, 1, 2, 5]), ...TEST_KEYS],\n      [Uint8Array.from([0]), ...TEST_VALUES],\n    );\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"Dupplicate key\", () => {\n    const eitherMap = builder.build(\n      [Uint8Array.from([0, 1, 2, 3]), ...TEST_KEYS],\n      [Uint8Array.from([0]), ...TEST_VALUES],\n    );\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"correct value\", () => {\n    mockCreateMerkleTree\n      .mockReturnValueOnce({\n        getRoot: () => Uint8Array.from([42, 43]),\n        size: () => TEST_KEYS.length,\n      })\n      .mockReturnValueOnce({\n        getRoot: () => Uint8Array.from([44, 45]),\n        size: () => TEST_VALUES.length,\n      });\n\n    const eitherMap = builder.build(TEST_KEYS, TEST_VALUES);\n    expect(eitherMap.isRight()).toStrictEqual(true);\n    expect(mockCreateMerkleTree).toHaveBeenCalledWith(TEST_KEYS);\n    expect(mockCreateMerkleTree).toHaveBeenCalledWith(TEST_VALUES);\n  });\n});\n"],
-  "mappings": "aAEA,IAAAA,EAAiC,8BAEjC,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAAY,CAChB,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,CAC9B,EAEMC,EAAc,CAClB,WAAW,KAAK,CAAC,EAAG,CAAC,CAAC,EACtB,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,GAAI,CAAC,EACxC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,GAAI,CAAC,EACzB,WAAW,KAAK,CAAC,IAAM,EAAE,CAAC,CAC5B,EAEMC,EAAuB,KAAK,GAAG,EAC/BC,EAAoC,CACxC,MAAOD,CACT,EACA,IAAIE,EAEJ,WAAW,IAAM,CACf,KAAK,cAAc,EACnBA,EAAU,IAAI,mBAAiBD,CAAc,CAC/C,CAAC,EAED,GAAG,sBAAuB,IAAM,CAC9B,MAAME,EAAYD,EAAQ,MAAMJ,EAAW,CACzC,WAAW,KAAK,CAAC,CAAC,CAAC,EACnB,GAAGC,CACL,CAAC,EACD,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,mBAAoB,IAAM,CAC3B,MAAMA,EAAYD,EAAQ,MACxB,CAAC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAAG,GAAGJ,CAAS,EAC5C,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,EAAG,GAAGC,CAAW,CACvC,EACA,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,iBAAkB,IAAM,CACzB,MAAMA,EAAYD,EAAQ,MACxB,CAAC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAAG,GAAGJ,CAAS,EAC5C,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,EAAG,GAAGC,CAAW,CACvC,EACA,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,gBAAiB,IAAM,CACxBH,EACG,oBAAoB,CACnB,QAAS,IAAM,WAAW,KAAK,CAAC,GAAI,EAAE,CAAC,EACvC,KAAM,IAAMF,EAAU,MACxB,CAAC,EACA,oBAAoB,CACnB,QAAS,IAAM,WAAW,KAAK,CAAC,GAAI,EAAE,CAAC,EACvC,KAAM,IAAMC,EAAY,MAC1B,CAAC,EAEH,MAAMI,EAAYD,EAAQ,MAAMJ,EAAWC,CAAW,EACtD,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC9C,OAAOH,CAAoB,EAAE,qBAAqBF,CAAS,EAC3D,OAAOE,CAAoB,EAAE,qBAAqBD,CAAW,CAC/D,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { type MerkleTreeBuilder } from \"@internal/merkle-tree/service/MerkleTreeBuilder\";\n\nimport { MerkleMapBuilder } from \"./MerkleMapBuilder\";\n\ndescribe(\"MerkleMapBuilder\", () => {\n  const TEST_KEYS = [\n    Uint8Array.from([0, 1, 2, 3]),\n    Uint8Array.from([0, 1, 2, 4]),\n    Uint8Array.from([0, 1, 2, 5]),\n    Uint8Array.from([0, 2, 2, 3]),\n    Uint8Array.from([1, 1, 2, 3]),\n  ];\n\n  const TEST_VALUES = [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0xff, 0xff, 0xff, 0xff]),\n    Uint8Array.from([0, 1, 2, 5]),\n    Uint8Array.from([0, 0xff]),\n    Uint8Array.from([0xfe, 57]),\n  ];\n\n  const mockCreateMerkleTree = vi.fn();\n  const mockMerkleTree: MerkleTreeBuilder = {\n    build: mockCreateMerkleTree,\n  } as unknown as MerkleTreeBuilder;\n  let builder: MerkleMapBuilder;\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n    builder = new MerkleMapBuilder(mockMerkleTree);\n  });\n\n  it(\"Invalid value count\", () => {\n    const eitherMap = builder.build(TEST_KEYS, [\n      Uint8Array.from([0]),\n      ...TEST_VALUES,\n    ]);\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"Invalid ordering\", () => {\n    const eitherMap = builder.build(\n      [Uint8Array.from([0, 1, 2, 5]), ...TEST_KEYS],\n      [Uint8Array.from([0]), ...TEST_VALUES],\n    );\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"Dupplicate key\", () => {\n    const eitherMap = builder.build(\n      [Uint8Array.from([0, 1, 2, 3]), ...TEST_KEYS],\n      [Uint8Array.from([0]), ...TEST_VALUES],\n    );\n    expect(eitherMap.isRight()).toStrictEqual(false);\n  });\n\n  it(\"correct value\", () => {\n    mockCreateMerkleTree\n      .mockReturnValueOnce({\n        getRoot: () => Uint8Array.from([42, 43]),\n        size: () => TEST_KEYS.length,\n      })\n      .mockReturnValueOnce({\n        getRoot: () => Uint8Array.from([44, 45]),\n        size: () => TEST_VALUES.length,\n      });\n\n    const eitherMap = builder.build(TEST_KEYS, TEST_VALUES);\n    expect(eitherMap.isRight()).toStrictEqual(true);\n    expect(mockCreateMerkleTree).toHaveBeenCalledWith(TEST_KEYS);\n    expect(mockCreateMerkleTree).toHaveBeenCalledWith(TEST_VALUES);\n  });\n});\n"],
+  "mappings": "aAEA,IAAAA,EAAiC,8BAEjC,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAAY,CAChB,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,CAC9B,EAEMC,EAAc,CAClB,WAAW,KAAK,CAAC,EAAG,CAAC,CAAC,EACtB,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,GAAI,CAAC,EACxC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAC5B,WAAW,KAAK,CAAC,EAAG,GAAI,CAAC,EACzB,WAAW,KAAK,CAAC,IAAM,EAAE,CAAC,CAC5B,EAEMC,EAAuB,GAAG,GAAG,EAC7BC,EAAoC,CACxC,MAAOD,CACT,EACA,IAAIE,EAEJ,WAAW,IAAM,CACf,GAAG,cAAc,EACjBA,EAAU,IAAI,mBAAiBD,CAAc,CAC/C,CAAC,EAED,GAAG,sBAAuB,IAAM,CAC9B,MAAME,EAAYD,EAAQ,MAAMJ,EAAW,CACzC,WAAW,KAAK,CAAC,CAAC,CAAC,EACnB,GAAGC,CACL,CAAC,EACD,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,mBAAoB,IAAM,CAC3B,MAAMA,EAAYD,EAAQ,MACxB,CAAC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAAG,GAAGJ,CAAS,EAC5C,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,EAAG,GAAGC,CAAW,CACvC,EACA,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,iBAAkB,IAAM,CACzB,MAAMA,EAAYD,EAAQ,MACxB,CAAC,WAAW,KAAK,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAAG,GAAGJ,CAAS,EAC5C,CAAC,WAAW,KAAK,CAAC,CAAC,CAAC,EAAG,GAAGC,CAAW,CACvC,EACA,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAK,CACjD,CAAC,EAED,GAAG,gBAAiB,IAAM,CACxBH,EACG,oBAAoB,CACnB,QAAS,IAAM,WAAW,KAAK,CAAC,GAAI,EAAE,CAAC,EACvC,KAAM,IAAMF,EAAU,MACxB,CAAC,EACA,oBAAoB,CACnB,QAAS,IAAM,WAAW,KAAK,CAAC,GAAI,EAAE,CAAC,EACvC,KAAM,IAAMC,EAAY,MAC1B,CAAC,EAEH,MAAMI,EAAYD,EAAQ,MAAMJ,EAAWC,CAAW,EACtD,OAAOI,EAAU,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC9C,OAAOH,CAAoB,EAAE,qBAAqBF,CAAS,EAC3D,OAAOE,CAAoB,EAAE,qBAAqBD,CAAW,CAC/D,CAAC,CACH,CAAC",
   "names": ["import_MerkleMapBuilder", "TEST_KEYS", "TEST_VALUES", "mockCreateMerkleTree", "mockMerkleTree", "builder", "eitherMap"]
 }

package/lib/cjs/internal/merkle-tree/service/MerkleTreeBuilder.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var e=require("@ledgerhq/device-management-kit"),d=require("purify-ts"),n=require("./MerkleTreeBuilder"),l=require("./Sha256HasherService");const i={data:[],leaves:[],nodes:[],root:(0,e.hexaStringToBuffer)("0000000000000000000000000000000000000000000000000000000000000000")},s={data:[Uint8Array.from([42,43])],leaves:[Uint8Array.from([0,42,43])],nodes:[],root:(0,e.hexaStringToBuffer)("8a707e40cad3d1070b0a1c87dd362cdf4d546e6d2a7aaf155c798932f71de4ad")},b={data:[Uint8Array.from([0,1,2,3,4]),Uint8Array.from([5,6,7,8,9])],leaves:[Uint8Array.from([0,0,1,2,3,4]),Uint8Array.from([0,5,6,7,8,9])],nodes:[[(0,e.hexaStringToBuffer)("9d1cf1e12fa64e20ccd2a5387504b99e89e24ef55dba8399637c3f5b6615c0ad"),(0,e.hexaStringToBuffer)("7dc17a7849e10103f73b8fa5a4b829f6292a1a59272e0e0c9def83a9c0f86de1")]],root:(0,e.hexaStringToBuffer)("dc65c307a70fb21f4c8ea0cdfc5ff3291adae1db9ce5410b93dcb43c5eddd793")},r={data:[Uint8Array.from([0]),Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])],leaves:[Uint8Array.from([0,0]),Uint8Array.from([0,1]),Uint8Array.from([0,2]),Uint8Array.from([0,3])],nodes:[[(0,e.hexaStringToBuffer)("96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7"),(0,e.hexaStringToBuffer)("b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2"),(0,e.hexaStringToBuffer)("fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f"),(0,e.hexaStringToBuffer)("583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d")],[(0,e.hexaStringToBuffer)("a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a"),(0,e.hexaStringToBuffer)("52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825")]],root:(0,e.hexaStringToBuffer)("9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb")},f={data:[Uint8Array.from([0]),Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3]),Uint8Array.from([4]),Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7]),Uint8Array.from([8]),Uint8Array.from([9]),Uint8Array.from([10])],leaves:[Uint8Array.from([0,0]),Uint8Array.from([0,1]),Uint8Array.from([0,2]),Uint8Array.from([0,3]),Uint8Array.from([0,4]),Uint8Array.from([0,5]),Uint8Array.from([0,6]),Uint8Array.from([0,7]),Uint8Array.from([0,8]),Uint8Array.from([0,9]),Uint8Array.from([0,10])],nodes:[[(0,e.hexaStringToBuffer)("96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7"),(0,e.hexaStringToBuffer)("b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2"),(0,e.hexaStringToBuffer)("fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f"),(0,e.hexaStringToBuffer)("583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d"),(0,e.hexaStringToBuffer)("4f35212d12f9ad2036492c95f1fe79baf4ec7bd9bef3dffa7579f2293ff546a4"),(0,e.hexaStringToBuffer)("9f1afa4dc124cba73134e82ff50f17c8f7164257c79fed9a13f5943a6acb8e3d"),(0,e.hexaStringToBuffer)("40d88127d4d31a3891f41598eeed41174e5bc89b1eb9bbd66a8cbfc09956a3fd"),(0,e.hexaStringToBuffer)("2ecd8a6b7d2845546659ad4cf443533cf921b19dc81fa83934e83821b4dfdcb7"),(0,e.hexaStringToBuffer)("b4c43b50bf245bd727623e3c775a8fcfb8d823d00b57dd65f7f79dd33f126315"),(0,e.hexaStringToBuffer)("c87479cd656e7e3ad6bd8db402e8027df454b2b0c42ff29e093458beb98a23d4"),(0,e.hexaStringToBuffer)("67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e")],[(0,e.hexaStringToBuffer)("a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a"),(0,e.hexaStringToBuffer)("52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825"),(0,e.hexaStringToBuffer)("4b8c129ed14cce2c08cfc6766db7f8cdb133b5f698b8de3d5890ea7ff7f0a8d1"),(0,e.hexaStringToBuffer)("bbb0feb32f648c73fe170518bcec1f675af1b780dc23d6fbf30b745c1ca5fa11"),(0,e.hexaStringToBuffer)("f7e08e9a9e87822bd79a0bf24d14c7a431be807336bd3c50ccb2d249b2a91404"),(0,e.hexaStringToBuffer)("67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e")],[(0,e.hexaStringToBuffer)("9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb"),(0,e.hexaStringToBuffer)("c1fe42b33ebb8e8a7e4a90abc481c7434e2be02cff2f6a18d7ffab4f1e25891b"),(0,e.hexaStringToBuffer)("e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50")],[(0,e.hexaStringToBuffer)("ef7f49b620f6c7ea9b963a214da34b5021c6ded8ed57734380a311ab726aa907"),(0,e.hexaStringToBuffer)("e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50")]],root:(0,e.hexaStringToBuffer)("e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac")};describe("MerkleTreeBuilder",()=>{let c;beforeEach(()=>{jest.resetAllMocks(),c=new n.MerkleTreeBuilder(new l.Sha256HasherService)}),it("Get small tree root and leaves",()=>{const a=c.build(r.data);expect(a.getRoot()).toStrictEqual(r.root),expect(a.size()).toStrictEqual(r.leaves.length),expect(a.getLeaves().map(t=>t.value)).toStrictEqual(r.leaves),expect(a.getLeaves().map(t=>t.hash)).toStrictEqual(r.nodes[0]),r.nodes[0].forEach((t,o)=>{expect(a.getLeafHash(o)).toStrictEqual((0,d.Just)(t))}),expect(a.getLeafHash(-1)).toStrictEqual(d.Nothing),expect(a.getLeafHash(r.nodes[0].length)).toStrictEqual(d.Nothing)}),it("Get big tree root and leaves",()=>{const a=c.build(f.data);expect(a.getRoot()).toStrictEqual(f.root),expect(a.size()).toStrictEqual(f.leaves.length),expect(a.getLeaves().map(t=>t.value)).toStrictEqual(f.leaves),expect(a.getLeaves().map(t=>t.hash)).toStrictEqual(f.nodes[0]),f.nodes[0].forEach((t,o)=>{expect(a.getLeafHash(o)).toStrictEqual((0,d.Just)(t))}),expect(a.getLeafHash(-1)).toStrictEqual(d.Nothing),expect(a.getLeafHash(f.nodes[0].length)).toStrictEqual(d.Nothing)}),it("Get small tree merkle proof",()=>{const t=c.build(r.data).getProof(2);expect(t.isJust()).toStrictEqual(!0);const o=t.unsafeCoerce();expect(o).toStrictEqual([r.nodes[0][3],r.nodes[1][0]])}),it("Get big tree merkle proof",()=>{const t=c.build(f.data).getProof(2);expect(t.isJust()).toStrictEqual(!0);const o=t.unsafeCoerce();expect(o).toStrictEqual([f.nodes[0][3],f.nodes[1][0],f.nodes[2][1],f.nodes[3][1]])}),it("Get out-of-bound merkle proof",()=>{const a=c.build(r.data);let t=a.getProof(-1);expect(t.isJust()).toStrictEqual(!1),t=a.getProof(5),expect(t.isJust()).toStrictEqual(!1)}),it("Empty tree",()=>{const a=c.build(i.data);expect(a.getRoot()).toStrictEqual(i.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!1)}),it("One-leaf tree",()=>{const a=c.build(s.data);expect(a.getRoot()).toStrictEqual(s.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([])}),it("Tiny tree",()=>{const a=c.build(b.data);expect(a.getRoot()).toStrictEqual(b.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([b.nodes[0][1]])})});
+"use strict";var e=require("@ledgerhq/device-management-kit"),d=require("purify-ts"),s=require("./MerkleTreeBuilder"),l=require("./Sha256HasherService");const i={data:[],leaves:[],nodes:[],root:(0,e.hexaStringToBuffer)("0000000000000000000000000000000000000000000000000000000000000000")},n={data:[Uint8Array.from([42,43])],leaves:[Uint8Array.from([0,42,43])],nodes:[],root:(0,e.hexaStringToBuffer)("8a707e40cad3d1070b0a1c87dd362cdf4d546e6d2a7aaf155c798932f71de4ad")},b={data:[Uint8Array.from([0,1,2,3,4]),Uint8Array.from([5,6,7,8,9])],leaves:[Uint8Array.from([0,0,1,2,3,4]),Uint8Array.from([0,5,6,7,8,9])],nodes:[[(0,e.hexaStringToBuffer)("9d1cf1e12fa64e20ccd2a5387504b99e89e24ef55dba8399637c3f5b6615c0ad"),(0,e.hexaStringToBuffer)("7dc17a7849e10103f73b8fa5a4b829f6292a1a59272e0e0c9def83a9c0f86de1")]],root:(0,e.hexaStringToBuffer)("dc65c307a70fb21f4c8ea0cdfc5ff3291adae1db9ce5410b93dcb43c5eddd793")},r={data:[Uint8Array.from([0]),Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3])],leaves:[Uint8Array.from([0,0]),Uint8Array.from([0,1]),Uint8Array.from([0,2]),Uint8Array.from([0,3])],nodes:[[(0,e.hexaStringToBuffer)("96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7"),(0,e.hexaStringToBuffer)("b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2"),(0,e.hexaStringToBuffer)("fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f"),(0,e.hexaStringToBuffer)("583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d")],[(0,e.hexaStringToBuffer)("a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a"),(0,e.hexaStringToBuffer)("52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825")]],root:(0,e.hexaStringToBuffer)("9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb")},f={data:[Uint8Array.from([0]),Uint8Array.from([1]),Uint8Array.from([2]),Uint8Array.from([3]),Uint8Array.from([4]),Uint8Array.from([5]),Uint8Array.from([6]),Uint8Array.from([7]),Uint8Array.from([8]),Uint8Array.from([9]),Uint8Array.from([10])],leaves:[Uint8Array.from([0,0]),Uint8Array.from([0,1]),Uint8Array.from([0,2]),Uint8Array.from([0,3]),Uint8Array.from([0,4]),Uint8Array.from([0,5]),Uint8Array.from([0,6]),Uint8Array.from([0,7]),Uint8Array.from([0,8]),Uint8Array.from([0,9]),Uint8Array.from([0,10])],nodes:[[(0,e.hexaStringToBuffer)("96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7"),(0,e.hexaStringToBuffer)("b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2"),(0,e.hexaStringToBuffer)("fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f"),(0,e.hexaStringToBuffer)("583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d"),(0,e.hexaStringToBuffer)("4f35212d12f9ad2036492c95f1fe79baf4ec7bd9bef3dffa7579f2293ff546a4"),(0,e.hexaStringToBuffer)("9f1afa4dc124cba73134e82ff50f17c8f7164257c79fed9a13f5943a6acb8e3d"),(0,e.hexaStringToBuffer)("40d88127d4d31a3891f41598eeed41174e5bc89b1eb9bbd66a8cbfc09956a3fd"),(0,e.hexaStringToBuffer)("2ecd8a6b7d2845546659ad4cf443533cf921b19dc81fa83934e83821b4dfdcb7"),(0,e.hexaStringToBuffer)("b4c43b50bf245bd727623e3c775a8fcfb8d823d00b57dd65f7f79dd33f126315"),(0,e.hexaStringToBuffer)("c87479cd656e7e3ad6bd8db402e8027df454b2b0c42ff29e093458beb98a23d4"),(0,e.hexaStringToBuffer)("67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e")],[(0,e.hexaStringToBuffer)("a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a"),(0,e.hexaStringToBuffer)("52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825"),(0,e.hexaStringToBuffer)("4b8c129ed14cce2c08cfc6766db7f8cdb133b5f698b8de3d5890ea7ff7f0a8d1"),(0,e.hexaStringToBuffer)("bbb0feb32f648c73fe170518bcec1f675af1b780dc23d6fbf30b745c1ca5fa11"),(0,e.hexaStringToBuffer)("f7e08e9a9e87822bd79a0bf24d14c7a431be807336bd3c50ccb2d249b2a91404"),(0,e.hexaStringToBuffer)("67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e")],[(0,e.hexaStringToBuffer)("9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb"),(0,e.hexaStringToBuffer)("c1fe42b33ebb8e8a7e4a90abc481c7434e2be02cff2f6a18d7ffab4f1e25891b"),(0,e.hexaStringToBuffer)("e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50")],[(0,e.hexaStringToBuffer)("ef7f49b620f6c7ea9b963a214da34b5021c6ded8ed57734380a311ab726aa907"),(0,e.hexaStringToBuffer)("e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50")]],root:(0,e.hexaStringToBuffer)("e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac")};describe("MerkleTreeBuilder",()=>{let c;beforeEach(()=>{vi.resetAllMocks(),c=new s.MerkleTreeBuilder(new l.Sha256HasherService)}),it("Get small tree root and leaves",()=>{const a=c.build(r.data);expect(a.getRoot()).toStrictEqual(r.root),expect(a.size()).toStrictEqual(r.leaves.length),expect(a.getLeaves().map(t=>t.value)).toStrictEqual(r.leaves),expect(a.getLeaves().map(t=>t.hash)).toStrictEqual(r.nodes[0]),r.nodes[0].forEach((t,o)=>{expect(a.getLeafHash(o)).toStrictEqual((0,d.Just)(t))}),expect(a.getLeafHash(-1)).toStrictEqual(d.Nothing),expect(a.getLeafHash(r.nodes[0].length)).toStrictEqual(d.Nothing)}),it("Get big tree root and leaves",()=>{const a=c.build(f.data);expect(a.getRoot()).toStrictEqual(f.root),expect(a.size()).toStrictEqual(f.leaves.length),expect(a.getLeaves().map(t=>t.value)).toStrictEqual(f.leaves),expect(a.getLeaves().map(t=>t.hash)).toStrictEqual(f.nodes[0]),f.nodes[0].forEach((t,o)=>{expect(a.getLeafHash(o)).toStrictEqual((0,d.Just)(t))}),expect(a.getLeafHash(-1)).toStrictEqual(d.Nothing),expect(a.getLeafHash(f.nodes[0].length)).toStrictEqual(d.Nothing)}),it("Get small tree merkle proof",()=>{const t=c.build(r.data).getProof(2);expect(t.isJust()).toStrictEqual(!0);const o=t.unsafeCoerce();expect(o).toStrictEqual([r.nodes[0][3],r.nodes[1][0]])}),it("Get big tree merkle proof",()=>{const t=c.build(f.data).getProof(2);expect(t.isJust()).toStrictEqual(!0);const o=t.unsafeCoerce();expect(o).toStrictEqual([f.nodes[0][3],f.nodes[1][0],f.nodes[2][1],f.nodes[3][1]])}),it("Get out-of-bound merkle proof",()=>{const a=c.build(r.data);let t=a.getProof(-1);expect(t.isJust()).toStrictEqual(!1),t=a.getProof(5),expect(t.isJust()).toStrictEqual(!1)}),it("Empty tree",()=>{const a=c.build(i.data);expect(a.getRoot()).toStrictEqual(i.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!1)}),it("One-leaf tree",()=>{const a=c.build(n.data);expect(a.getRoot()).toStrictEqual(n.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([])}),it("Tiny tree",()=>{const a=c.build(b.data);expect(a.getRoot()).toStrictEqual(b.root);const t=a.getProof(0);expect(t.isJust()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([b.nodes[0][1]])})});
 //# sourceMappingURL=MerkleTreeBuilder.test.js.map

package/lib/cjs/internal/merkle-tree/service/MerkleTreeBuilder.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/merkle-tree/service/MerkleTreeBuilder.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { MerkleTreeBuilder } from \"./MerkleTreeBuilder\";\nimport { Sha256HasherService } from \"./Sha256HasherService\";\n\nconst EMPTY_TREE = {\n  data: [],\n  leaves: [],\n  nodes: [],\n  root: hexaStringToBuffer(\n    \"0000000000000000000000000000000000000000000000000000000000000000\",\n  ),\n};\n\nconst ONE_LEAF_TREE = {\n  data: [Uint8Array.from([42, 43])],\n  leaves: [Uint8Array.from([0, 42, 43])],\n  nodes: [],\n  root: hexaStringToBuffer(\n    \"8a707e40cad3d1070b0a1c87dd362cdf4d546e6d2a7aaf155c798932f71de4ad\",\n  ),\n};\n\nconst TINY_TREE = {\n  data: [Uint8Array.from([0, 1, 2, 3, 4]), Uint8Array.from([5, 6, 7, 8, 9])],\n  leaves: [\n    Uint8Array.from([0, 0, 1, 2, 3, 4]),\n    Uint8Array.from([0, 5, 6, 7, 8, 9]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"9d1cf1e12fa64e20ccd2a5387504b99e89e24ef55dba8399637c3f5b6615c0ad\",\n      )!,\n      hexaStringToBuffer(\n        \"7dc17a7849e10103f73b8fa5a4b829f6292a1a59272e0e0c9def83a9c0f86de1\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"dc65c307a70fb21f4c8ea0cdfc5ff3291adae1db9ce5410b93dcb43c5eddd793\",\n  )!,\n};\n\nconst SMALL_TREE = {\n  data: [\n    Uint8Array.from([0]),\n    Uint8Array.from([1]),\n    Uint8Array.from([2]),\n    Uint8Array.from([3]),\n  ],\n  leaves: [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0, 1]),\n    Uint8Array.from([0, 2]),\n    Uint8Array.from([0, 3]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7\",\n      )!,\n      hexaStringToBuffer(\n        \"b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2\",\n      )!,\n      hexaStringToBuffer(\n        \"fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f\",\n      )!,\n      hexaStringToBuffer(\n        \"583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a\",\n      )!,\n      hexaStringToBuffer(\n        \"52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n  )!,\n};\n\nconst BIG_TREE = {\n  data: [\n    Uint8Array.from([0]),\n    Uint8Array.from([1]),\n    Uint8Array.from([2]),\n    Uint8Array.from([3]),\n    Uint8Array.from([4]),\n    Uint8Array.from([5]),\n    Uint8Array.from([6]),\n    Uint8Array.from([7]),\n    Uint8Array.from([8]),\n    Uint8Array.from([9]),\n    Uint8Array.from([10]),\n  ],\n  leaves: [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0, 1]),\n    Uint8Array.from([0, 2]),\n    Uint8Array.from([0, 3]),\n    Uint8Array.from([0, 4]),\n    Uint8Array.from([0, 5]),\n    Uint8Array.from([0, 6]),\n    Uint8Array.from([0, 7]),\n    Uint8Array.from([0, 8]),\n    Uint8Array.from([0, 9]),\n    Uint8Array.from([0, 10]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7\",\n      )!,\n      hexaStringToBuffer(\n        \"b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2\",\n      )!,\n      hexaStringToBuffer(\n        \"fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f\",\n      )!,\n      hexaStringToBuffer(\n        \"583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d\",\n      )!,\n      hexaStringToBuffer(\n        \"4f35212d12f9ad2036492c95f1fe79baf4ec7bd9bef3dffa7579f2293ff546a4\",\n      )!,\n      hexaStringToBuffer(\n        \"9f1afa4dc124cba73134e82ff50f17c8f7164257c79fed9a13f5943a6acb8e3d\",\n      )!,\n      hexaStringToBuffer(\n        \"40d88127d4d31a3891f41598eeed41174e5bc89b1eb9bbd66a8cbfc09956a3fd\",\n      )!,\n      hexaStringToBuffer(\n        \"2ecd8a6b7d2845546659ad4cf443533cf921b19dc81fa83934e83821b4dfdcb7\",\n      )!,\n      hexaStringToBuffer(\n        \"b4c43b50bf245bd727623e3c775a8fcfb8d823d00b57dd65f7f79dd33f126315\",\n      )!,\n      hexaStringToBuffer(\n        \"c87479cd656e7e3ad6bd8db402e8027df454b2b0c42ff29e093458beb98a23d4\",\n      )!,\n      hexaStringToBuffer(\n        \"67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a\",\n      )!,\n      hexaStringToBuffer(\n        \"52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825\",\n      )!,\n      hexaStringToBuffer(\n        \"4b8c129ed14cce2c08cfc6766db7f8cdb133b5f698b8de3d5890ea7ff7f0a8d1\",\n      )!,\n      hexaStringToBuffer(\n        \"bbb0feb32f648c73fe170518bcec1f675af1b780dc23d6fbf30b745c1ca5fa11\",\n      )!,\n      hexaStringToBuffer(\n        \"f7e08e9a9e87822bd79a0bf24d14c7a431be807336bd3c50ccb2d249b2a91404\",\n      )!,\n      hexaStringToBuffer(\n        \"67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n      )!,\n      hexaStringToBuffer(\n        \"c1fe42b33ebb8e8a7e4a90abc481c7434e2be02cff2f6a18d7ffab4f1e25891b\",\n      )!,\n      hexaStringToBuffer(\n        \"e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"ef7f49b620f6c7ea9b963a214da34b5021c6ded8ed57734380a311ab726aa907\",\n      )!,\n      hexaStringToBuffer(\n        \"e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac\",\n  )!,\n};\n\ndescribe(\"MerkleTreeBuilder\", () => {\n  let builder: MerkleTreeBuilder;\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n    builder = new MerkleTreeBuilder(new Sha256HasherService());\n  });\n\n  it(\"Get small tree root and leaves\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(SMALL_TREE.root);\n    expect(tree.size()).toStrictEqual(SMALL_TREE.leaves.length);\n    expect(tree.getLeaves().map((l) => l.value)).toStrictEqual(\n      SMALL_TREE.leaves,\n    );\n    expect(tree.getLeaves().map((l) => l.hash)).toStrictEqual(\n      SMALL_TREE.nodes[0],\n    );\n    SMALL_TREE.nodes[0]!.forEach((hash, index) => {\n      expect(tree.getLeafHash(index)).toStrictEqual(Just(hash));\n    });\n    expect(tree.getLeafHash(-1)).toStrictEqual(Nothing);\n    expect(tree.getLeafHash(SMALL_TREE.nodes[0]!.length)).toStrictEqual(\n      Nothing,\n    );\n  });\n\n  it(\"Get big tree root and leaves\", () => {\n    const tree = builder.build(BIG_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(BIG_TREE.root);\n    expect(tree.size()).toStrictEqual(BIG_TREE.leaves.length);\n    expect(tree.getLeaves().map((l) => l.value)).toStrictEqual(BIG_TREE.leaves);\n    expect(tree.getLeaves().map((l) => l.hash)).toStrictEqual(\n      BIG_TREE.nodes[0],\n    );\n    BIG_TREE.nodes[0]!.forEach((hash, index) => {\n      expect(tree.getLeafHash(index)).toStrictEqual(Just(hash));\n    });\n    expect(tree.getLeafHash(-1)).toStrictEqual(Nothing);\n    expect(tree.getLeafHash(BIG_TREE.nodes[0]!.length)).toStrictEqual(Nothing);\n  });\n\n  it(\"Get small tree merkle proof\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    const maybeProof = tree.getProof(2);\n    expect(maybeProof.isJust()).toStrictEqual(true);\n    const proof = maybeProof.unsafeCoerce();\n\n    expect(proof).toStrictEqual([\n      SMALL_TREE.nodes[0]![3],\n      SMALL_TREE.nodes[1]![0],\n    ]);\n  });\n\n  it(\"Get big tree merkle proof\", () => {\n    const tree = builder.build(BIG_TREE.data);\n    const maybeProof = tree.getProof(2);\n    expect(maybeProof.isJust()).toStrictEqual(true);\n    const proof = maybeProof.unsafeCoerce();\n\n    expect(proof).toStrictEqual([\n      BIG_TREE.nodes[0]![3],\n      BIG_TREE.nodes[1]![0],\n      BIG_TREE.nodes[2]![1],\n      BIG_TREE.nodes[3]![1],\n    ]);\n  });\n\n  it(\"Get out-of-bound merkle proof\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    let maybeProof = tree.getProof(-1);\n    expect(maybeProof.isJust()).toStrictEqual(false);\n    maybeProof = tree.getProof(5);\n    expect(maybeProof.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Empty tree\", () => {\n    const tree = builder.build(EMPTY_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(EMPTY_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(false);\n  });\n\n  it(\"One-leaf tree\", () => {\n    const tree = builder.build(ONE_LEAF_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(ONE_LEAF_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(true);\n    expect(proof.unsafeCoerce()).toStrictEqual([]);\n  });\n\n  it(\"Tiny tree\", () => {\n    const tree = builder.build(TINY_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(TINY_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(true);\n    expect(proof.unsafeCoerce()).toStrictEqual([TINY_TREE.nodes[0]![1]]);\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { MerkleTreeBuilder } from \"./MerkleTreeBuilder\";\nimport { Sha256HasherService } from \"./Sha256HasherService\";\n\nconst EMPTY_TREE = {\n  data: [],\n  leaves: [],\n  nodes: [],\n  root: hexaStringToBuffer(\n    \"0000000000000000000000000000000000000000000000000000000000000000\",\n  ),\n};\n\nconst ONE_LEAF_TREE = {\n  data: [Uint8Array.from([42, 43])],\n  leaves: [Uint8Array.from([0, 42, 43])],\n  nodes: [],\n  root: hexaStringToBuffer(\n    \"8a707e40cad3d1070b0a1c87dd362cdf4d546e6d2a7aaf155c798932f71de4ad\",\n  ),\n};\n\nconst TINY_TREE = {\n  data: [Uint8Array.from([0, 1, 2, 3, 4]), Uint8Array.from([5, 6, 7, 8, 9])],\n  leaves: [\n    Uint8Array.from([0, 0, 1, 2, 3, 4]),\n    Uint8Array.from([0, 5, 6, 7, 8, 9]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"9d1cf1e12fa64e20ccd2a5387504b99e89e24ef55dba8399637c3f5b6615c0ad\",\n      )!,\n      hexaStringToBuffer(\n        \"7dc17a7849e10103f73b8fa5a4b829f6292a1a59272e0e0c9def83a9c0f86de1\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"dc65c307a70fb21f4c8ea0cdfc5ff3291adae1db9ce5410b93dcb43c5eddd793\",\n  )!,\n};\n\nconst SMALL_TREE = {\n  data: [\n    Uint8Array.from([0]),\n    Uint8Array.from([1]),\n    Uint8Array.from([2]),\n    Uint8Array.from([3]),\n  ],\n  leaves: [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0, 1]),\n    Uint8Array.from([0, 2]),\n    Uint8Array.from([0, 3]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7\",\n      )!,\n      hexaStringToBuffer(\n        \"b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2\",\n      )!,\n      hexaStringToBuffer(\n        \"fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f\",\n      )!,\n      hexaStringToBuffer(\n        \"583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a\",\n      )!,\n      hexaStringToBuffer(\n        \"52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n  )!,\n};\n\nconst BIG_TREE = {\n  data: [\n    Uint8Array.from([0]),\n    Uint8Array.from([1]),\n    Uint8Array.from([2]),\n    Uint8Array.from([3]),\n    Uint8Array.from([4]),\n    Uint8Array.from([5]),\n    Uint8Array.from([6]),\n    Uint8Array.from([7]),\n    Uint8Array.from([8]),\n    Uint8Array.from([9]),\n    Uint8Array.from([10]),\n  ],\n  leaves: [\n    Uint8Array.from([0, 0]),\n    Uint8Array.from([0, 1]),\n    Uint8Array.from([0, 2]),\n    Uint8Array.from([0, 3]),\n    Uint8Array.from([0, 4]),\n    Uint8Array.from([0, 5]),\n    Uint8Array.from([0, 6]),\n    Uint8Array.from([0, 7]),\n    Uint8Array.from([0, 8]),\n    Uint8Array.from([0, 9]),\n    Uint8Array.from([0, 10]),\n  ],\n  nodes: [\n    [\n      hexaStringToBuffer(\n        \"96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7\",\n      )!,\n      hexaStringToBuffer(\n        \"b413f47d13ee2fe6c845b2ee141af81de858df4ec549a58b7970bb96645bc8d2\",\n      )!,\n      hexaStringToBuffer(\n        \"fcf0a6c700dd13e274b6fba8deea8dd9b26e4eedde3495717cac8408c9c5177f\",\n      )!,\n      hexaStringToBuffer(\n        \"583c7dfb7b3055d99465544032a571e10a134b1b6f769422bbb71fd7fa167a5d\",\n      )!,\n      hexaStringToBuffer(\n        \"4f35212d12f9ad2036492c95f1fe79baf4ec7bd9bef3dffa7579f2293ff546a4\",\n      )!,\n      hexaStringToBuffer(\n        \"9f1afa4dc124cba73134e82ff50f17c8f7164257c79fed9a13f5943a6acb8e3d\",\n      )!,\n      hexaStringToBuffer(\n        \"40d88127d4d31a3891f41598eeed41174e5bc89b1eb9bbd66a8cbfc09956a3fd\",\n      )!,\n      hexaStringToBuffer(\n        \"2ecd8a6b7d2845546659ad4cf443533cf921b19dc81fa83934e83821b4dfdcb7\",\n      )!,\n      hexaStringToBuffer(\n        \"b4c43b50bf245bd727623e3c775a8fcfb8d823d00b57dd65f7f79dd33f126315\",\n      )!,\n      hexaStringToBuffer(\n        \"c87479cd656e7e3ad6bd8db402e8027df454b2b0c42ff29e093458beb98a23d4\",\n      )!,\n      hexaStringToBuffer(\n        \"67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"a20bf9a7cc2dc8a08f5f415a71b19f6ac427bab54d24eec868b5d3103449953a\",\n      )!,\n      hexaStringToBuffer(\n        \"52c56b473e5246933e7852989cd9feba3b38f078742b93afff1e65ed46797825\",\n      )!,\n      hexaStringToBuffer(\n        \"4b8c129ed14cce2c08cfc6766db7f8cdb133b5f698b8de3d5890ea7ff7f0a8d1\",\n      )!,\n      hexaStringToBuffer(\n        \"bbb0feb32f648c73fe170518bcec1f675af1b780dc23d6fbf30b745c1ca5fa11\",\n      )!,\n      hexaStringToBuffer(\n        \"f7e08e9a9e87822bd79a0bf24d14c7a431be807336bd3c50ccb2d249b2a91404\",\n      )!,\n      hexaStringToBuffer(\n        \"67ebbd370daa02ba9aadd05d8e091e862d0d8bcadafdf2a22360240a42fe922e\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"9bcd51240af4005168f033121ba85be5a6ed4f0e6a5fac262066729b8fbfdecb\",\n      )!,\n      hexaStringToBuffer(\n        \"c1fe42b33ebb8e8a7e4a90abc481c7434e2be02cff2f6a18d7ffab4f1e25891b\",\n      )!,\n      hexaStringToBuffer(\n        \"e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50\",\n      )!,\n    ],\n    [\n      hexaStringToBuffer(\n        \"ef7f49b620f6c7ea9b963a214da34b5021c6ded8ed57734380a311ab726aa907\",\n      )!,\n      hexaStringToBuffer(\n        \"e4b894272eb88bed1830cbef82d1c7aee37612a9e7131a5bdd0ae1a6e8f3ff50\",\n      )!,\n    ],\n  ],\n  root: hexaStringToBuffer(\n    \"e177ad5a8a17108dad67c70a51266681aa02b9e2b7ad6a0357585ba4289982ac\",\n  )!,\n};\n\ndescribe(\"MerkleTreeBuilder\", () => {\n  let builder: MerkleTreeBuilder;\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n    builder = new MerkleTreeBuilder(new Sha256HasherService());\n  });\n\n  it(\"Get small tree root and leaves\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(SMALL_TREE.root);\n    expect(tree.size()).toStrictEqual(SMALL_TREE.leaves.length);\n    expect(tree.getLeaves().map((l) => l.value)).toStrictEqual(\n      SMALL_TREE.leaves,\n    );\n    expect(tree.getLeaves().map((l) => l.hash)).toStrictEqual(\n      SMALL_TREE.nodes[0],\n    );\n    SMALL_TREE.nodes[0]!.forEach((hash, index) => {\n      expect(tree.getLeafHash(index)).toStrictEqual(Just(hash));\n    });\n    expect(tree.getLeafHash(-1)).toStrictEqual(Nothing);\n    expect(tree.getLeafHash(SMALL_TREE.nodes[0]!.length)).toStrictEqual(\n      Nothing,\n    );\n  });\n\n  it(\"Get big tree root and leaves\", () => {\n    const tree = builder.build(BIG_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(BIG_TREE.root);\n    expect(tree.size()).toStrictEqual(BIG_TREE.leaves.length);\n    expect(tree.getLeaves().map((l) => l.value)).toStrictEqual(BIG_TREE.leaves);\n    expect(tree.getLeaves().map((l) => l.hash)).toStrictEqual(\n      BIG_TREE.nodes[0],\n    );\n    BIG_TREE.nodes[0]!.forEach((hash, index) => {\n      expect(tree.getLeafHash(index)).toStrictEqual(Just(hash));\n    });\n    expect(tree.getLeafHash(-1)).toStrictEqual(Nothing);\n    expect(tree.getLeafHash(BIG_TREE.nodes[0]!.length)).toStrictEqual(Nothing);\n  });\n\n  it(\"Get small tree merkle proof\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    const maybeProof = tree.getProof(2);\n    expect(maybeProof.isJust()).toStrictEqual(true);\n    const proof = maybeProof.unsafeCoerce();\n\n    expect(proof).toStrictEqual([\n      SMALL_TREE.nodes[0]![3],\n      SMALL_TREE.nodes[1]![0],\n    ]);\n  });\n\n  it(\"Get big tree merkle proof\", () => {\n    const tree = builder.build(BIG_TREE.data);\n    const maybeProof = tree.getProof(2);\n    expect(maybeProof.isJust()).toStrictEqual(true);\n    const proof = maybeProof.unsafeCoerce();\n\n    expect(proof).toStrictEqual([\n      BIG_TREE.nodes[0]![3],\n      BIG_TREE.nodes[1]![0],\n      BIG_TREE.nodes[2]![1],\n      BIG_TREE.nodes[3]![1],\n    ]);\n  });\n\n  it(\"Get out-of-bound merkle proof\", () => {\n    const tree = builder.build(SMALL_TREE.data);\n    let maybeProof = tree.getProof(-1);\n    expect(maybeProof.isJust()).toStrictEqual(false);\n    maybeProof = tree.getProof(5);\n    expect(maybeProof.isJust()).toStrictEqual(false);\n  });\n\n  it(\"Empty tree\", () => {\n    const tree = builder.build(EMPTY_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(EMPTY_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(false);\n  });\n\n  it(\"One-leaf tree\", () => {\n    const tree = builder.build(ONE_LEAF_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(ONE_LEAF_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(true);\n    expect(proof.unsafeCoerce()).toStrictEqual([]);\n  });\n\n  it(\"Tiny tree\", () => {\n    const tree = builder.build(TINY_TREE.data);\n    expect(tree.getRoot()).toStrictEqual(TINY_TREE.root);\n    const proof = tree.getProof(0);\n    expect(proof.isJust()).toStrictEqual(true);\n    expect(proof.unsafeCoerce()).toStrictEqual([TINY_TREE.nodes[0]![1]]);\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_device_management_kit", "import_purify_ts", "import_MerkleTreeBuilder", "import_Sha256HasherService", "EMPTY_TREE", "ONE_LEAF_TREE", "TINY_TREE", "SMALL_TREE", "BIG_TREE", "builder", "tree", "l", "hash", "index", "maybeProof", "proof"]
 }

package/lib/cjs/internal/psbt/di/psbtModule.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var l=Object.defineProperty;var z=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var S=(r,e)=>{for(var a in e)l(r,a,{get:e[a],enumerable:!0})},V=(r,e,a,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of D(e))!c.call(r,o)&&o!==a&&l(r,o,{get:()=>e[o],enumerable:!(i=z(e,o))||i.enumerable});return r};var _=r=>V(l({},"__esModule",{value:!0}),r);var K={};S(K,{psbtModuleFactory:()=>b});module.exports=_(K);var m=require("inversify"),t=require("../../psbt/di/psbtTypes"),p=require("../../psbt/service/key/DefaultKeySerializer"),f=require("../../psbt/service/key-pair/DefaultKeyPairSerializer"),u=require("../../psbt/service/psbt/DefaultPsbtMapper"),s=require("../../psbt/service/psbt/DefaultPsbtSerializer"),P=require("../../psbt/service/psbt/DefaultPsbtV2Normalizer"),n=require("../../psbt/service/value/DefaultValueFactory"),y=require("../../psbt/service/value/DefaultValueParser");const b=()=>new m.ContainerModule((r,e,a,i,o,M,F)=>{r(t.psbtTypes.KeySerializer).to(p.DefaultKeySerializer),r(t.psbtTypes.KeyPairSerializer).to(f.DefaultKeyPairSerializer),r(t.psbtTypes.PsbtMapper).to(u.DefaultPsbtMapper),r(t.psbtTypes.PsbtV2Normalizer).to(P.DefaultPsbtV2Normalizer),r(t.psbtTypes.PsbtSerializer).to(s.DefaultPsbtSerializer),r(t.psbtTypes.ValueFactory).to(n.DefaultValueFactory),r(t.psbtTypes.ValueParser).to(y.DefaultValueParser)});0&&(module.exports={psbtModuleFactory});
+"use strict";var l=Object.defineProperty;var D=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var V=Object.prototype.hasOwnProperty;var c=(r,e)=>{for(var a in e)l(r,a,{get:e[a],enumerable:!0})},K=(r,e,a,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of S(e))!V.call(r,o)&&o!==a&&l(r,o,{get:()=>e[o],enumerable:!(i=D(e,o))||i.enumerable});return r};var M=r=>K(l({},"__esModule",{value:!0}),r);var b={};c(b,{psbtModuleFactory:()=>F});module.exports=M(b);var m=require("inversify"),t=require("../../psbt/di/psbtTypes"),p=require("../../psbt/service/key/DefaultKeySerializer"),f=require("../../psbt/service/key-pair/DefaultKeyPairSerializer"),u=require("../../psbt/service/psbt/DefaultPsbtMapper"),s=require("../../psbt/service/psbt/DefaultPsbtSerializer"),P=require("../../psbt/service/psbt/DefaultPsbtV2Normalizer"),y=require("../../psbt/service/value/DefaultValueFactory"),z=require("../../psbt/service/value/DefaultValueParser");const F=()=>new m.ContainerModule(({bind:r})=>{r(t.psbtTypes.KeySerializer).to(p.DefaultKeySerializer),r(t.psbtTypes.KeyPairSerializer).to(f.DefaultKeyPairSerializer),r(t.psbtTypes.PsbtMapper).to(u.DefaultPsbtMapper),r(t.psbtTypes.PsbtV2Normalizer).to(P.DefaultPsbtV2Normalizer),r(t.psbtTypes.PsbtSerializer).to(s.DefaultPsbtSerializer),r(t.psbtTypes.ValueFactory).to(y.DefaultValueFactory),r(t.psbtTypes.ValueParser).to(z.DefaultValueParser)});0&&(module.exports={psbtModuleFactory});
 //# sourceMappingURL=psbtModule.js.map

package/lib/cjs/internal/psbt/di/psbtModule.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/psbt/di/psbtModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { psbtTypes } from \"@internal/psbt/di/psbtTypes\";\nimport { DefaultKeySerializer } from \"@internal/psbt/service/key/DefaultKeySerializer\";\nimport { DefaultKeyPairSerializer } from \"@internal/psbt/service/key-pair/DefaultKeyPairSerializer\";\nimport { DefaultPsbtMapper } from \"@internal/psbt/service/psbt/DefaultPsbtMapper\";\nimport { DefaultPsbtSerializer } from \"@internal/psbt/service/psbt/DefaultPsbtSerializer\";\nimport { DefaultPsbtV2Normalizer } from \"@internal/psbt/service/psbt/DefaultPsbtV2Normalizer\";\nimport { DefaultValueFactory } from \"@internal/psbt/service/value/DefaultValueFactory\";\nimport { DefaultValueParser } from \"@internal/psbt/service/value/DefaultValueParser\";\n\nexport const psbtModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(psbtTypes.KeySerializer).to(DefaultKeySerializer);\n      bind(psbtTypes.KeyPairSerializer).to(DefaultKeyPairSerializer);\n      bind(psbtTypes.PsbtMapper).to(DefaultPsbtMapper);\n      bind(psbtTypes.PsbtV2Normalizer).to(DefaultPsbtV2Normalizer);\n      bind(psbtTypes.PsbtSerializer).to(DefaultPsbtSerializer);\n      bind(psbtTypes.ValueFactory).to(DefaultValueFactory);\n      bind(psbtTypes.ValueParser).to(DefaultValueParser);\n    },\n  );\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA0B,uCAC1BC,EAAqC,2DACrCC,EAAyC,oEACzCC,EAAkC,yDAClCC,EAAsC,6DACtCC,EAAwC,+DACxCC,EAAoC,4DACpCC,EAAmC,2DAE5B,MAAMV,EAAoB,IAC/B,IAAI,kBACF,CACEW,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAK,YAAU,aAAa,EAAE,GAAG,sBAAoB,EACrDA,EAAK,YAAU,iBAAiB,EAAE,GAAG,0BAAwB,EAC7DA,EAAK,YAAU,UAAU,EAAE,GAAG,mBAAiB,EAC/CA,EAAK,YAAU,gBAAgB,EAAE,GAAG,yBAAuB,EAC3DA,EAAK,YAAU,cAAc,EAAE,GAAG,uBAAqB,EACvDA,EAAK,YAAU,YAAY,EAAE,GAAG,qBAAmB,EACnDA,EAAK,YAAU,WAAW,EAAE,GAAG,oBAAkB,CACnD,CACF",
-  "names": ["psbtModule_exports", "__export", "psbtModuleFactory", "__toCommonJS", "import_inversify", "import_psbtTypes", "import_DefaultKeySerializer", "import_DefaultKeyPairSerializer", "import_DefaultPsbtMapper", "import_DefaultPsbtSerializer", "import_DefaultPsbtV2Normalizer", "import_DefaultValueFactory", "import_DefaultValueParser", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { psbtTypes } from \"@internal/psbt/di/psbtTypes\";\nimport { DefaultKeySerializer } from \"@internal/psbt/service/key/DefaultKeySerializer\";\nimport { DefaultKeyPairSerializer } from \"@internal/psbt/service/key-pair/DefaultKeyPairSerializer\";\nimport { DefaultPsbtMapper } from \"@internal/psbt/service/psbt/DefaultPsbtMapper\";\nimport { DefaultPsbtSerializer } from \"@internal/psbt/service/psbt/DefaultPsbtSerializer\";\nimport { DefaultPsbtV2Normalizer } from \"@internal/psbt/service/psbt/DefaultPsbtV2Normalizer\";\nimport { DefaultValueFactory } from \"@internal/psbt/service/value/DefaultValueFactory\";\nimport { DefaultValueParser } from \"@internal/psbt/service/value/DefaultValueParser\";\n\nexport const psbtModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(psbtTypes.KeySerializer).to(DefaultKeySerializer);\n    bind(psbtTypes.KeyPairSerializer).to(DefaultKeyPairSerializer);\n    bind(psbtTypes.PsbtMapper).to(DefaultPsbtMapper);\n    bind(psbtTypes.PsbtV2Normalizer).to(DefaultPsbtV2Normalizer);\n    bind(psbtTypes.PsbtSerializer).to(DefaultPsbtSerializer);\n    bind(psbtTypes.ValueFactory).to(DefaultValueFactory);\n    bind(psbtTypes.ValueParser).to(DefaultValueParser);\n  });\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA0B,uCAC1BC,EAAqC,2DACrCC,EAAyC,oEACzCC,EAAkC,yDAClCC,EAAsC,6DACtCC,EAAwC,+DACxCC,EAAoC,4DACpCC,EAAmC,2DAE5B,MAAMV,EAAoB,IAC/B,IAAI,kBAAgB,CAAC,CAAE,KAAAW,CAAK,IAAM,CAChCA,EAAK,YAAU,aAAa,EAAE,GAAG,sBAAoB,EACrDA,EAAK,YAAU,iBAAiB,EAAE,GAAG,0BAAwB,EAC7DA,EAAK,YAAU,UAAU,EAAE,GAAG,mBAAiB,EAC/CA,EAAK,YAAU,gBAAgB,EAAE,GAAG,yBAAuB,EAC3DA,EAAK,YAAU,cAAc,EAAE,GAAG,uBAAqB,EACvDA,EAAK,YAAU,YAAY,EAAE,GAAG,qBAAmB,EACnDA,EAAK,YAAU,WAAW,EAAE,GAAG,oBAAkB,CACnD,CAAC",
+  "names": ["psbtModule_exports", "__export", "psbtModuleFactory", "__toCommonJS", "import_inversify", "import_psbtTypes", "import_DefaultKeySerializer", "import_DefaultKeyPairSerializer", "import_DefaultPsbtMapper", "import_DefaultPsbtSerializer", "import_DefaultPsbtV2Normalizer", "import_DefaultValueFactory", "import_DefaultValueParser", "bind"]
 }

package/lib/cjs/internal/psbt/di/psbtModule.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var o=require("inversify"),r=require("./psbtModule");describe("PsbtModuleFactory",()=>{describe("Default",()=>{let t,e;beforeEach(()=>{e=(0,r.psbtModuleFactory)(),t=new o.Container,t.load(e)}),it("should return the psbt service module",()=>{expect(e).toBeDefined()})})});
+"use strict";var o=require("inversify"),r=require("./psbtModule");describe("PsbtModuleFactory",()=>{describe("Default",()=>{let t,e;beforeEach(()=>{e=(0,r.psbtModuleFactory)(),t=new o.Container,t.loadSync(e)}),it("should return the psbt service module",()=>{expect(e).toBeDefined()})})});
 //# sourceMappingURL=psbtModule.test.js.map

package/lib/cjs/internal/psbt/di/psbtModule.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/psbt/di/psbtModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { psbtModuleFactory } from \"./psbtModule\";\n\ndescribe(\"PsbtModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof psbtModuleFactory>;\n    beforeEach(() => {\n      mod = psbtModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the psbt service module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAkC,wBAElC,SAAS,oBAAqB,IAAM,CAClC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,qBAAkB,EACxBD,EAAY,IAAI,YAChBA,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,wCAAyC,IAAM,CAChD,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { psbtModuleFactory } from \"./psbtModule\";\n\ndescribe(\"PsbtModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof psbtModuleFactory>;\n    beforeEach(() => {\n      mod = psbtModuleFactory();\n      container = new Container();\n      container.loadSync(mod);\n    });\n\n    it(\"should return the psbt service module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAkC,wBAElC,SAAS,oBAAqB,IAAM,CAClC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,qBAAkB,EACxBD,EAAY,IAAI,YAChBA,EAAU,SAASC,CAAG,CACxB,CAAC,EAED,GAAG,wCAAyC,IAAM,CAChD,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_inversify", "import_psbtModule", "container", "mod"]
 }

package/lib/cjs/internal/psbt/model/Key.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var y=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var b=(t,e)=>{for(var r in e)y(t,r,{get:e[r],enumerable:!0})},u=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of p(e))!f.call(t,a)&&a!==r&&y(t,a,{get:()=>e[a],enumerable:!(n=i(e,a))||n.enumerable});return t};var l=t=>u(y({},"__esModule",{value:!0}),t);var c={};b(c,{Key:()=>d});module.exports=l(c);var o=require("@ledgerhq/device-management-kit"),s=require("../../utils/Varint");class d{constructor(e,r=new Uint8Array){this.keyType=e;this.keyData=r}toHexaString(){const e=new o.ByteArrayBuilder().addBufferToData((0,s.encodeVarint)(this.keyType).unsafeCoerce()).addBufferToData(this.keyData).build();return(0,o.bufferToHexaString)(e).slice(2)}}0&&(module.exports={Key});
+"use strict";var y=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var b=(t,e)=>{for(var r in e)y(t,r,{get:e[r],enumerable:!0})},u=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of i(e))!p.call(t,a)&&a!==r&&y(t,a,{get:()=>e[a],enumerable:!(n=f(e,a))||n.enumerable});return t};var l=t=>u(y({},"__esModule",{value:!0}),t);var T={};b(T,{Key:()=>d});module.exports=l(T);var o=require("@ledgerhq/device-management-kit"),s=require("../../utils/Varint");class d{constructor(e,r=new Uint8Array){this.keyType=e;this.keyData=r}toHexaString(){const e=new o.ByteArrayBuilder().addBufferToData((0,s.encodeVarint)(this.keyType).unsafeCoerce()).addBufferToData(this.keyData).build();return(0,o.bufferToHexaString)(e,!1)}}0&&(module.exports={Key});
 //# sourceMappingURL=Key.js.map

package/lib/cjs/internal/psbt/model/Key.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/psbt/model/Key.ts"],
-  "sourcesContent": ["import {\n  bufferToHexaString,\n  ByteArrayBuilder,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type PsbtGlobal, type PsbtIn, type PsbtOut } from \"./Psbt\";\n\n/**\n * According to specification, key-pair is formatted as:\n * <keylen> <keytype> <keydata> <valuelen> <valuedata>\n * with:\n *   <keylen>: The compact size unsigned integer containing the combined length of <keytype> and <keydata>\n *   <keytype>: A compact size unsigned integer representing the type\n *   <valuelen>: The compact size unsigned integer containing the length of <valuedata>\n * For more informations:\n * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#specification\n */\nexport type KeyType = PsbtGlobal | PsbtIn | PsbtOut;\n\nexport class Key {\n  constructor(\n    readonly keyType: KeyType,\n    readonly keyData: Uint8Array = new Uint8Array(),\n  ) {}\n\n  toHexaString(): string {\n    // Safe to extract keyType here since its value is a valid PSBT key type.\n    const buffer = new ByteArrayBuilder()\n      .addBufferToData(encodeVarint(this.keyType).unsafeCoerce())\n      .addBufferToData(this.keyData)\n      .build();\n    return bufferToHexaString(buffer).slice(2);\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,SAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAGO,2CAEPC,EAA6B,kCAgBtB,MAAMH,CAAI,CACf,YACWI,EACAC,EAAsB,IAAI,WACnC,CAFS,aAAAD,EACA,aAAAC,CACR,CAEH,cAAuB,CAErB,MAAMC,EAAS,IAAI,mBAAiB,EACjC,mBAAgB,gBAAa,KAAK,OAAO,EAAE,aAAa,CAAC,EACzD,gBAAgB,KAAK,OAAO,EAC5B,MAAM,EACT,SAAO,sBAAmBA,CAAM,EAAE,MAAM,CAAC,CAC3C,CACF",
+  "sourcesContent": ["import {\n  bufferToHexaString,\n  ByteArrayBuilder,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type PsbtGlobal, type PsbtIn, type PsbtOut } from \"./Psbt\";\n\n/**\n * According to specification, key-pair is formatted as:\n * <keylen> <keytype> <keydata> <valuelen> <valuedata>\n * with:\n *   <keylen>: The compact size unsigned integer containing the combined length of <keytype> and <keydata>\n *   <keytype>: A compact size unsigned integer representing the type\n *   <valuelen>: The compact size unsigned integer containing the length of <valuedata>\n * For more informations:\n * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#specification\n */\nexport type KeyType = PsbtGlobal | PsbtIn | PsbtOut;\n\nexport class Key {\n  constructor(\n    readonly keyType: KeyType,\n    readonly keyData: Uint8Array = new Uint8Array(),\n  ) {}\n\n  toHexaString(): string {\n    // Safe to extract keyType here since its value is a valid PSBT key type.\n    const buffer = new ByteArrayBuilder()\n      .addBufferToData(encodeVarint(this.keyType).unsafeCoerce())\n      .addBufferToData(this.keyData)\n      .build();\n    return bufferToHexaString(buffer, false);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,SAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAGO,2CAEPC,EAA6B,kCAgBtB,MAAMH,CAAI,CACf,YACWI,EACAC,EAAsB,IAAI,WACnC,CAFS,aAAAD,EACA,aAAAC,CACR,CAEH,cAAuB,CAErB,MAAMC,EAAS,IAAI,mBAAiB,EACjC,mBAAgB,gBAAa,KAAK,OAAO,EAAE,aAAa,CAAC,EACzD,gBAAgB,KAAK,OAAO,EAC5B,MAAM,EACT,SAAO,sBAAmBA,EAAQ,EAAK,CACzC,CACF",
   "names": ["Key_exports", "__export", "Key", "__toCommonJS", "import_device_management_kit", "import_Varint", "keyType", "keyData", "buffer"]
 }

package/lib/cjs/internal/psbt/service/psbt/DefaultPsbtMapper.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var P=Object.create;var l=Object.defineProperty;var x=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var B=Object.getPrototypeOf,R=Object.prototype.hasOwnProperty;var h=(o,f,c,a)=>{if(f&&typeof f=="object"||typeof f=="function")for(let n of k(f))!R.call(o,n)&&n!==c&&l(o,n,{get:()=>f[n],enumerable:!(a=x(f,n))||a.enumerable});return o};var S=(o,f,c)=>(c=o!=null?P(B(o)):{},h(f||!o||!o.__esModule?l(c,"default",{value:o,enumerable:!0}):c,o));var m=require("@ledgerhq/device-management-kit"),E=S(require("bitcoinjs-lib")),t=require("purify-ts"),u=require("../../../psbt/model/Psbt"),b=require("./DefaultPsbtMapper");describe("DefaultPsbtMapper tests",()=>{const o="70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000",f="cHNidP8BAKACAAAAAqsJSaCMWvfEm4IS9Bfi8Vqz9cM9zxU4IagTn4d6W3vkAAAAAAD+////qwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QBAAAAAP7///8CYDvqCwAAAAAZdqkUdopAu9dAy+gdmI5x3ipNXHE5ax2IrI4kAAAAAAAAGXapFG9GILVT+glechue4O/p+gOcykWXiKwAAAAAAAEA3wIAAAABJoFxNx7f8oXpN63upLN7eAAMBWbLs61kZBcTykIXG/YAAAAAakcwRAIgcLIkUSPmv0dNYMW1DAQ9TGkaXSQ18Jo0p2YqncJReQoCIAEynKnazygL3zB0DsA5BCJCLIHLRYOUV663b8Eu3ZWzASECZX0RjTNXuOD0ws1G23s59tnDjZpwq8ubLeXcjb/kzjH+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQEgAOH1BQAAAAAXqRQ1RebjO4MsRwUPJNPuuTycA5SLx4cBBBYAFIXRNTfy4mVAWjTbr6nj3aAfuCMIACICAurVlmh8qAYEPtw94RbN8p1eklfBls0FXPaYyNAr8k6ZELSmumcAAACAAAAAgAIAAIAAIgIDlPYr6d8ZlSxVh3aK63aYBhrSxKJciU9H2MFitNchPQUQtKa6ZwAAAIABAACAAgAAgAA=",c=(0,m.hexaStringToBuffer)(o),a=jest.fn(),n={deserialize:a},A=jest.fn(),d={normalize:A},s=()=>new u.Psbt;beforeEach(()=>{jest.resetAllMocks()}),it("Map hex string",()=>{const e=s(),r=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(o);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map base64 string",()=>{const e=s(),r=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(f);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map bjs transaction",()=>{const e=s(),r=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(E.Psbt.fromHex(o));expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map byte array",()=>{const e=s(),r=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map invalid string",()=>{const e=s(),r=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map("some random string");expect(p.isRight()).toStrictEqual(!1)}),it("Parser failure",()=>{const e=s();a.mockReturnValueOnce((0,t.Left)(new Error)),A.mockReturnValueOnce((0,t.Right)(e));const i=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(i.isRight()).toStrictEqual(!1)}),it("Normalizer failure",()=>{const e=s();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Left)(new Error));const i=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(i.isRight()).toStrictEqual(!1)})});
+"use strict";var P=Object.create;var l=Object.defineProperty;var x=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var B=Object.getPrototypeOf,R=Object.prototype.hasOwnProperty;var h=(o,s,c,a)=>{if(s&&typeof s=="object"||typeof s=="function")for(let n of k(s))!R.call(o,n)&&n!==c&&l(o,n,{get:()=>s[n],enumerable:!(a=x(s,n))||a.enumerable});return o};var S=(o,s,c)=>(c=o!=null?P(B(o)):{},h(s||!o||!o.__esModule?l(c,"default",{value:o,enumerable:!0}):c,o));var m=require("@ledgerhq/device-management-kit"),E=S(require("bitcoinjs-lib")),t=require("purify-ts"),u=require("../../../psbt/model/Psbt"),b=require("./DefaultPsbtMapper");describe("DefaultPsbtMapper tests",()=>{const o="70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000",s="cHNidP8BAKACAAAAAqsJSaCMWvfEm4IS9Bfi8Vqz9cM9zxU4IagTn4d6W3vkAAAAAAD+////qwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QBAAAAAP7///8CYDvqCwAAAAAZdqkUdopAu9dAy+gdmI5x3ipNXHE5ax2IrI4kAAAAAAAAGXapFG9GILVT+glechue4O/p+gOcykWXiKwAAAAAAAEA3wIAAAABJoFxNx7f8oXpN63upLN7eAAMBWbLs61kZBcTykIXG/YAAAAAakcwRAIgcLIkUSPmv0dNYMW1DAQ9TGkaXSQ18Jo0p2YqncJReQoCIAEynKnazygL3zB0DsA5BCJCLIHLRYOUV663b8Eu3ZWzASECZX0RjTNXuOD0ws1G23s59tnDjZpwq8ubLeXcjb/kzjH+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQEgAOH1BQAAAAAXqRQ1RebjO4MsRwUPJNPuuTycA5SLx4cBBBYAFIXRNTfy4mVAWjTbr6nj3aAfuCMIACICAurVlmh8qAYEPtw94RbN8p1eklfBls0FXPaYyNAr8k6ZELSmumcAAACAAAAAgAIAAIAAIgIDlPYr6d8ZlSxVh3aK63aYBhrSxKJciU9H2MFitNchPQUQtKa6ZwAAAIABAACAAgAAgAA=",c=(0,m.hexaStringToBuffer)(o),a=vi.fn(),n={deserialize:a},A=vi.fn(),d={normalize:A},f=()=>new u.Psbt;beforeEach(()=>{vi.resetAllMocks()}),it("Map hex string",()=>{const e=f(),r=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(o);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map base64 string",()=>{const e=f(),r=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(s);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map bjs transaction",()=>{const e=f(),r=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(E.Psbt.fromHex(o));expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map byte array",()=>{const e=f(),r=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(p.isRight()).toStrictEqual(!0),expect(p.unsafeCoerce()).toStrictEqual(r)}),it("Map invalid string",()=>{const e=f(),r=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Right)(r));const p=new b.DefaultPsbtMapper(n,d).map("some random string");expect(p.isRight()).toStrictEqual(!1)}),it("Parser failure",()=>{const e=f();a.mockReturnValueOnce((0,t.Left)(new Error)),A.mockReturnValueOnce((0,t.Right)(e));const i=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(i.isRight()).toStrictEqual(!1)}),it("Normalizer failure",()=>{const e=f();a.mockReturnValueOnce((0,t.Right)(e)),A.mockReturnValueOnce((0,t.Left)(new Error));const i=new b.DefaultPsbtMapper(n,d).map(c);expect(a).toHaveBeenCalledWith(c),expect(A).toHaveBeenCalledWith(e),expect(i.isRight()).toStrictEqual(!1)})});
 //# sourceMappingURL=DefaultPsbtMapper.test.js.map