@ledgerhq/cryptoassets 12.1.0 → 13.0.0-nightly.2

package/src/crypto-assets-importer/exchange/bep20.ts

@@ -6,15 +6,21 @@ type BEP20Exchange = [string, string, string];
 export const importBEP20Exchange = async (outputDir: string) => {
   console.log("importing bep 20 exchange tokens...");
   try {
-    const bep20Exchange = await fetchTokens<BEP20Exchange>("exchange/bep20.json");
+    const [bep20Exchange, hash] = await fetchTokens<BEP20Exchange>("exchange/bep20.json");
     fs.writeFileSync(`${outputDir}/exchange/bep20.json`, JSON.stringify(bep20Exchange));
+    if (hash) {
+      fs.writeFileSync(`${outputDir}/exchange/bep20-hash.json`, JSON.stringify(hash));
+    }
 
     const bep20ExchangeTypeStringified = `export type BEP20Exchange = [string, string, string];`;
+    const hashStringified = hash ? `export { default as hash } from "./bep20-hash.json";` : "";
     const tokensStringified = `import tokens from "./bep20.json";`;
     const exportstringified = `export default tokens as BEP20Exchange[];`;
 
     const tsFile = `${bep20ExchangeTypeStringified}
 
+${hashStringified}
+
 ${tokensStringified}
 
 ${exportstringified}

package/src/crypto-assets-importer/exchange/coins.ts

@@ -6,10 +6,14 @@ type CoinExchange = [string, string, string];
 export const importCoinsExchange = async (outputDir: string) => {
   console.log("importing coins exchange...");
   try {
-    const coinsExchange = await fetchTokens<CoinExchange>("exchange/coins.json");
+    const [coinsExchange, hash] = await fetchTokens<CoinExchange>("exchange/coins.json");
     fs.writeFileSync(`${outputDir}/exchange/coins.json`, JSON.stringify(coinsExchange));
+    if (hash) {
+      fs.writeFileSync(`${outputDir}/exchange/coin-hash.json`, JSON.stringify(hash));
+    }
 
     const coinExchangeTypeStringified = `export type Exchange = [string, string, string];`;
+    const hashStringified = hash ? `export { default as hash } from "./coin-hash.json";` : "";
     const exchangesStringified = `import exchanges from "./coins.json";`;
     const exportStringified = `export default exchanges as Exchange[];`;
 
@@ -17,6 +21,8 @@ export const importCoinsExchange = async (outputDir: string) => {
       `${outputDir}/exchange/coins.ts`,
       `${coinExchangeTypeStringified}
 
+${hashStringified}
+
 ${exchangesStringified}
 
 ${exportStringified}

package/src/crypto-assets-importer/exchange/erc20.ts

@@ -6,10 +6,14 @@ type ERC20Exchange = [string, string, string];
 export const importERC20Exchange = async (outputDir: string) => {
   console.log("importing ERC20 exchange...");
   try {
-    const erc20Exchange = await fetchTokens<ERC20Exchange>("exchange/erc20.json");
+    const [erc20Exchange, hash] = await fetchTokens<ERC20Exchange>("exchange/erc20.json");
     fs.writeFileSync(`${outputDir}/exchange/erc20.json`, JSON.stringify(erc20Exchange));
+    if (hash) {
+      fs.writeFileSync(`${outputDir}/exchange/erc20-hash.json`, JSON.stringify(hash));
+    }
 
     const erc20typeStringified = `export type ERC20Exchange = [string, string, string];`;
+    const hashStringified = hash ? `export { default as hash } from "./erc20-hash.json";` : "";
     const tokensStringified = `import exchanges from "./erc20.json";`;
     const exportStringified = `export default exchanges as ERC20Exchange[];`;
 
@@ -17,6 +21,8 @@ export const importERC20Exchange = async (outputDir: string) => {
       `${outputDir}/exchange/erc20.ts`,
       `${erc20typeStringified}
 
+${hashStringified}
+
 ${tokensStringified}
 
 ${exportStringified}

package/src/crypto-assets-importer/exchange/trc20.ts

@@ -0,0 +1,30 @@
+import fs from "fs";
+import { fetchTokens } from "../fetch";
+
+type TRC20Exchange = [string, string, string];
+
+export const importTRC20Exchange = async (outputDir: string) => {
+  console.log("importing TRC20 exchange...");
+  try {
+    const trc20Exchange = await fetchTokens<TRC20Exchange>("exchange/trc20.json");
+    fs.writeFileSync(`${outputDir}/exchange/trc20.json`, JSON.stringify(trc20Exchange));
+
+    const trc20typeStringified = `export type TRC20Exchange = [string, string, string];`;
+    const tokensStringified = `import exchanges from "./trc20.json";`;
+    const exportStringified = `export default exchanges as TRC20Exchange[];`;
+
+    fs.writeFileSync(
+      `${outputDir}/exchange/trc20.ts`,
+      `${trc20typeStringified}
+
+${tokensStringified}
+
+${exportStringified}
+`,
+    );
+
+    console.log("importing TRC20 exchange success");
+  } catch (err) {
+    console.error(err);
+  }
+};

package/src/crypto-assets-importer/fetch/fetch.test.ts

@@ -11,9 +11,12 @@ describe("fetcher", () => {
 
   it("should return data when fetched", async () => {
     const response = [{ myToken: { name: "myToken" } }];
-    mockedAxios.get.mockImplementation(() => Promise.resolve({ data: response }));
-    const tokens = await fetchTokens("tokens.json");
+    mockedAxios.get.mockImplementation(() =>
+      Promise.resolve({ data: response, headers: { etag: "hash" } }),
+    );
+    const [tokens, hash] = await fetchTokens("tokens.json");
     expect(tokens).toBe(response);
+    expect(hash).toBe("hash");
   });
 
   it("should throw error if fetch failed", async () => {

package/src/crypto-assets-importer/fetch/index.ts

@@ -2,10 +2,10 @@ import axios, { AxiosError } from "axios";
 
 const CRYPTO_ASSETS_BASE_URL = "https://cdn.live.ledger.com/cryptoassets";
 
-export const fetchTokens = async <T>(filename: string): Promise<T> => {
+export const fetchTokens = async <T>(filename: string): Promise<[T, string | undefined]> => {
   try {
-    const { data } = await axios.get<T>(`${CRYPTO_ASSETS_BASE_URL}/${filename}`);
-    return data;
+    const { data, headers } = await axios.get<T>(`${CRYPTO_ASSETS_BASE_URL}/${filename}`);
+    return [data, headers.etag];
   } catch (err) {
     const error = err as AxiosError;
     throw new Error(`${error.message} ${CRYPTO_ASSETS_BASE_URL}/${filename}`);

package/src/crypto-assets-importer/importers/asa/asa.test.ts

@@ -8,7 +8,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import ASA tokens", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: asa }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: asa, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -27,6 +29,8 @@ describe("import ASA tokens", () => {
 
 import tokens from "./asa.json";
 
+export { default as hash } from "./asa-hash.json";
+
 export default tokens as AlgorandASAToken[];
 `;
 
@@ -36,6 +40,7 @@ export default tokens as AlgorandASAToken[];
 
     expect(mockedAxios).toHaveBeenCalledWith(expect.stringMatching(/.*\/asa.json/));
     expect(mockedFs).toHaveBeenNthCalledWith(1, "asa.json", JSON.stringify(asa));
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "asa.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(2, "asa-hash.json", JSON.stringify("etagHash"));
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "asa.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/asa/index.ts

@@ -14,9 +14,13 @@ type AlgorandASAToken = [
 export const importAsaTokens = async (outputDir: string) => {
   try {
     console.log("importing asa tokens...");
-    const asaTokens = await fetchTokens<AlgorandASAToken[]>("asa.json");
+    const [asaTokens, hash] = await fetchTokens<AlgorandASAToken[]>("asa.json");
     const filePath = path.join(outputDir, "asa");
     fs.writeFileSync(`${filePath}.json`, JSON.stringify(asaTokens));
+    if (hash) {
+      fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+    }
+
     fs.writeFileSync(
       `${filePath}.ts`,
       `export type AlgorandASAToken = [
@@ -30,6 +34,8 @@ export const importAsaTokens = async (outputDir: string) => {
 
 import tokens from "./asa.json";
 
+${hash ? `export { default as hash } from "./asa-hash.json";` : ""}
+
 export default tokens as AlgorandASAToken[];
 `,
     );

package/src/crypto-assets-importer/importers/bep20/bep20.test.ts

@@ -8,7 +8,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import bep20", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: bep20 }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: bep20, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -31,6 +33,8 @@ describe("import bep20", () => {
 
 import tokens from "./bep20.json";
 
+export { default as hash } from "./bep20-hash.json";
+
 export default tokens as BEP20Token[];
 `;
 
@@ -40,6 +44,7 @@ export default tokens as BEP20Token[];
 
     expect(mockedAxios).toHaveBeenCalledWith(expect.stringMatching(/.*\/bep20.json/));
     expect(mockedFs).toHaveBeenNthCalledWith(1, "bep20.json", JSON.stringify(bep20));
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "bep20.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(2, "bep20-hash.json", JSON.stringify("etagHash"));
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "bep20.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/bep20/index.ts

@@ -18,11 +18,14 @@ type BEP20Token = [
 export const importBEP20 = async (outputDir: string) => {
   try {
     console.log("import BEP 20 tokens...");
-    const bep20 = await fetchTokens<BEP20Token[]>("bep20.json");
+    const [bep20, hash] = await fetchTokens<BEP20Token[]>("bep20.json");
     const filePath = path.join(outputDir, "bep20");
-    if (bep20) {
-      fs.writeFileSync(`${filePath}.json`, JSON.stringify(bep20));
+    fs.writeFileSync(`${filePath}.json`, JSON.stringify(bep20));
+    if (hash) {
+      fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+    }
 
+    if (bep20) {
       fs.writeFileSync(
         `${filePath}.ts`,
         `export type BEP20Token = [
@@ -40,6 +43,8 @@ export const importBEP20 = async (outputDir: string) => {
 
 import tokens from "./bep20.json";
 
+${hash ? `export { default as hash } from "./bep20-hash.json";` : null}
+
 export default tokens as BEP20Token[];
 `,
       );

package/src/crypto-assets-importer/importers/cardanoNative/cardanoNative.test.ts

@@ -10,7 +10,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import Cardano Native tokens", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: cardanoNativeTokens }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: cardanoNativeTokens, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -31,6 +33,8 @@ describe("import Cardano Native tokens", () => {
 
 import tokens from "./cardanoNative.json";
 
+export { default as hash } from "./cardanoNative-hash.json";
+
 export default tokens as CardanoNativeToken[];
 `;
 
@@ -44,6 +48,11 @@ export default tokens as CardanoNativeToken[];
       "cardanoNative.json",
       JSON.stringify(cardanoNativeTokens),
     );
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "cardanoNative.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(
+      2,
+      "cardanoNative-hash.json",
+      JSON.stringify("etagHash"),
+    );
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "cardanoNative.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/cardanoNative/index.ts

@@ -16,9 +16,15 @@ type CardanoNativeToken = [
 export const importCardanoNativeTokens = async (outputDir: string) => {
   try {
     console.log("importing cardanoNative tokens...");
-    const cardanoNativeTokens = await fetchTokens<CardanoNativeToken[]>("cardanoNative.json");
+    const [cardanoNativeTokens, hash] =
+      await fetchTokens<CardanoNativeToken[]>("cardanoNative.json");
     const filePath = path.join(outputDir, "cardanoNative");
 
+    fs.writeFileSync(`${filePath}.json`, JSON.stringify(cardanoNativeTokens));
+    if (hash) {
+      fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+    }
+
     const cardanoNativeTypeStringified = `export type CardanoNativeToken = [
   string, // parentCurrencyId
   string, // policyId
@@ -30,13 +36,14 @@ export const importCardanoNativeTokens = async (outputDir: string) => {
   boolean // disableCountervalue
 ];`;
 
-    fs.writeFileSync(`${filePath}.json`, JSON.stringify(cardanoNativeTokens));
     fs.writeFileSync(
       `${filePath}.ts`,
       `${cardanoNativeTypeStringified}
 
 import tokens from "./cardanoNative.json";
 
+${hash ? `export { default as hash } from "./cardanoNative-hash.json";` : null}
+
 export default tokens as CardanoNativeToken[];
 `,
     );

package/src/crypto-assets-importer/importers/eip712/eip712.test.ts

@@ -22,7 +22,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import EIP 712 tokens", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: eip712Tokens }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: eip712Tokens, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -30,7 +32,10 @@ describe("import EIP 712 tokens", () => {
   });
 
   it("should output the file in the correct format", async () => {
-    const expectedFile = `export default ${JSON.stringify(eip712Tokens, null, 2)};`;
+    const expectedFile = `import EIP712 from "./eip712.json";
+export { default as hash } from "./eip712-hash.json";
+export default EIP712;
+`;
 
     const mockedFs = (fs.writeFileSync = jest.fn());
 
@@ -38,6 +43,7 @@ describe("import EIP 712 tokens", () => {
 
     expect(mockedAxios).toHaveBeenCalledWith(expect.stringMatching(/.*\/eip712.json/));
     expect(mockedFs).toHaveBeenNthCalledWith(1, "eip712.json", JSON.stringify(eip712Tokens));
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "eip712.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(2, "eip712-hash.json", JSON.stringify("etagHash"));
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "eip712.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/eip712/index.ts

@@ -13,11 +13,18 @@ type EIP712 = {
 export const importEIP712 = async (outputDir: string) => {
   console.log("importing ERC712 tokens....");
   try {
-    const eip712 = await fetchTokens<EIP712>("eip712.json");
+    const [eip712, hash] = await fetchTokens<EIP712>("eip712.json");
     if (eip712) {
       const filePath = path.join(outputDir, "eip712");
-      const tsContent = `export default ${JSON.stringify(eip712, null, 2)};`;
       fs.writeFileSync(`${filePath}.json`, JSON.stringify(eip712));
+      if (hash) {
+        fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+      }
+
+      const tsContent = `import EIP712 from "./eip712.json";
+${hash ? `export { default as hash } from "./eip712-hash.json";` : null}
+export default EIP712;
+`;
       fs.writeFileSync(`${filePath}.ts`, tsContent);
       console.log("importing ERC712 tokens sucess");
     }

package/src/crypto-assets-importer/importers/erc20/erc20.test.ts

@@ -8,7 +8,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import ERC20", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: erc20 }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: erc20, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -32,6 +34,8 @@ describe("import ERC20", () => {
 
 import tokens from "./erc20.json";
 
+export { default as hash } from "./erc20-hash.json";
+
 export default tokens as ERC20Token[];
 `;
 
@@ -41,6 +45,7 @@ export default tokens as ERC20Token[];
 
     expect(mockedAxios).toHaveBeenCalledWith(expect.stringMatching(/.*\/erc20.json/));
     expect(mockedFs).toHaveBeenNthCalledWith(1, "erc20.json", JSON.stringify(erc20));
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "erc20.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(2, "erc20-hash.json", JSON.stringify("etagHash"));
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "erc20.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/erc20/index.ts

@@ -19,11 +19,14 @@ type ERC20Token = [
 export const importERC20 = async (outputDir: string) => {
   try {
     console.log("importing ERC20 tokens....");
-    const erc20 = await fetchTokens<ERC20Token>("erc20.json");
+    const [erc20, hash] = await fetchTokens<ERC20Token>("erc20.json");
 
     if (erc20) {
       const filePath = path.join(outputDir, "erc20");
       fs.writeFileSync(`${filePath}.json`, JSON.stringify(erc20));
+      if (hash) {
+        fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+      }
 
       const erc20TokenTypeStringified = `export type ERC20Token = [
   string, // parent currency id
@@ -43,6 +46,8 @@ export const importERC20 = async (outputDir: string) => {
 
 import tokens from "./erc20.json";
 
+${hash ? `export { default as hash } from "./erc20-hash.json";` : null}
+
 export default tokens as ERC20Token[];
 `;
 

package/src/crypto-assets-importer/importers/erc20-signature/erc20-signature.test.ts

@@ -7,7 +7,9 @@ const erc20Signatures = "erc20Signature";
 describe("import Cardano Native tokens", () => {
   beforeEach(() => {
     const mockedAxios = jest.spyOn(axios, "get");
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: erc20Signatures }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: erc20Signatures, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -15,7 +17,12 @@ describe("import Cardano Native tokens", () => {
   });
 
   it("should output the file in the correct format", async () => {
-    const expectedFile = `export default ${JSON.stringify(erc20Signatures, null, 2)};`;
+    const expectedFile = `import ERC20Signatures from "./erc20-signatures.json";
+
+export { default as hash } from "./erc20-signatures-hash.json";
+
+export default ERC20Signatures;
+`;
 
     const mockedFs = (fs.writeFileSync = jest.fn());
 
@@ -26,6 +33,11 @@ describe("import Cardano Native tokens", () => {
       "erc20-signatures.json",
       JSON.stringify(erc20Signatures),
     );
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "erc20-signatures.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(
+      2,
+      "erc20-signatures-hash.json",
+      JSON.stringify("etagHash"),
+    );
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "erc20-signatures.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/erc20-signature/index.ts

@@ -5,13 +5,22 @@ import { fetchTokens } from "../../fetch";
 export const importERC20Signatures = async (outputDir: string) => {
   console.log("importing erc20 signatures...");
   try {
-    const erc20Signatures = await fetchTokens<string>("erc20-signatures.json");
+    const [erc20Signatures, hash] = await fetchTokens<string>("erc20-signatures.json");
     const filePath = path.join(outputDir, "erc20-signatures");
     if (erc20Signatures) {
       fs.writeFileSync(`${filePath}.json`, JSON.stringify(erc20Signatures));
+      if (hash) {
+        fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+      }
+
       fs.writeFileSync(
         `${filePath}.ts`,
-        `export default ${JSON.stringify(erc20Signatures, null, 2)};`,
+        `import ERC20Signatures from "./erc20-signatures.json";
+
+${hash ? `export { default as hash } from "./erc20-signatures-hash.json";` : null}
+
+export default ERC20Signatures;
+`,
       );
       console.log("importing erc20 signatures: success");
     }

package/src/crypto-assets-importer/importers/esdt/esdt.test.ts

@@ -8,7 +8,9 @@ const mockedAxios = jest.spyOn(axios, "get");
 
 describe("import ESDT tokens", () => {
   beforeEach(() => {
-    mockedAxios.mockImplementation(() => Promise.resolve({ data: esdtTokens }));
+    mockedAxios.mockImplementation(() =>
+      Promise.resolve({ data: esdtTokens, headers: { etag: "etagHash" } }),
+    );
   });
 
   afterEach(() => {
@@ -27,6 +29,8 @@ describe("import ESDT tokens", () => {
 
 import tokens from "./esdt.json";
 
+export { default as hash } from "./esdt-hash.json";
+
 export default tokens as ElrondESDTToken[];
 `;
 
@@ -36,6 +40,7 @@ export default tokens as ElrondESDTToken[];
 
     expect(mockedAxios).toHaveBeenCalledWith(expect.stringMatching(/.*\/esdt.json/));
     expect(mockedFs).toHaveBeenNthCalledWith(1, "esdt.json", JSON.stringify(esdtTokens));
-    expect(mockedFs).toHaveBeenNthCalledWith(2, "esdt.ts", expectedFile);
+    expect(mockedFs).toHaveBeenNthCalledWith(2, "esdt-hash.json", JSON.stringify("etagHash"));
+    expect(mockedFs).toHaveBeenNthCalledWith(3, "esdt.ts", expectedFile);
   });
 });

package/src/crypto-assets-importer/importers/esdt/index.ts

@@ -14,7 +14,7 @@ type ElrondESDTToken = [
 export const importESDTTokens = async (outputDir: string) => {
   try {
     console.log("importing esdt tokens...");
-    const esdtTokens = await fetchTokens<ElrondESDTToken[]>("esdt.json");
+    const [esdtTokens, hash] = await fetchTokens<ElrondESDTToken[]>("esdt.json");
     const filePath = path.join(outputDir, "esdt");
 
     const estTypeStringified = `export type ElrondESDTToken = [
@@ -27,12 +27,18 @@ export const importESDTTokens = async (outputDir: string) => {
 ];`;
 
     fs.writeFileSync(`${filePath}.json`, JSON.stringify(esdtTokens));
+    if (hash) {
+      fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+    }
+
     fs.writeFileSync(
       `${filePath}.ts`,
       `${estTypeStringified}
 
 import tokens from "./esdt.json";
 
+${hash ? `export { default as hash } from "./esdt-hash.json";` : null}
+
 export default tokens as ElrondESDTToken[];
 `,
     );

package/src/crypto-assets-importer/importers/evm/evm.test.ts

@@ -13,9 +13,9 @@ describe("import EVM Token", () => {
     const mockedAxios = jest.spyOn(axios, "get");
     mockedAxios.mockImplementation(url => {
       if (url.endsWith("erc20.json")) {
-        return Promise.resolve({ data: evmToken });
+        return Promise.resolve({ data: evmToken, headers: { etag: "etagHash" } });
       } else if (url.endsWith("erc20-signatures.json")) {
-        return Promise.resolve({ data: evmTokenSignature });
+        return Promise.resolve({ data: evmTokenSignature, headers: { etag: "signatureEtagHash" } });
       }
 
       return Promise.reject("Unexpected route call");
@@ -31,18 +31,28 @@ describe("import EVM Token", () => {
 
     await importTokenByChainId(".", 1);
 
-    const expectedIndex = `import tokens from "./erc20.json";
-import signatures from "./erc20-signatures.json";
-
-export default { tokens, signatures };
+    const expectedIndex = `export { default as tokens } from "./erc20.json";
+export { default as signatures } from "./erc20-signatures.json";
+export { default as hash } from "./erc20-hash.json";
+export { default as signaturesHash } from "./erc20-signatures-hash.json";
 `;
 
     expect(mockedFs).toHaveBeenNthCalledWith(1, "evm/1/erc20.json", JSON.stringify(evmToken));
     expect(mockedFs).toHaveBeenNthCalledWith(
       2,
+      "evm/1/erc20-hash.json",
+      JSON.stringify("etagHash"),
+    );
+    expect(mockedFs).toHaveBeenNthCalledWith(
+      3,
+      "evm/1/erc20-signatures-hash.json",
+      JSON.stringify("signatureEtagHash"),
+    );
+    expect(mockedFs).toHaveBeenNthCalledWith(
+      4,
       "evm/1/erc20-signatures.json",
       JSON.stringify(evmTokenSignature),
     );
-    expect(mockedFs).toHaveBeenNthCalledWith(3, "evm/1/index.ts", expectedIndex);
+    expect(mockedFs).toHaveBeenNthCalledWith(5, "evm/1/index.ts", expectedIndex);
   });
 });