@ledgerhq/cryptoassets 12.1.0-next.0 → 12.1.0-nightly.0

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);
   });
 });

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

@@ -23,12 +23,14 @@ const chainNames = new Map<number, string>();
 export const importTokenByChainId = async (outputDir: string, chainId: number) => {
   try {
     console.log(`importing chain with chainId: ${chainId}...`);
-    const erc20 = await fetchTokens<EVMToken[]>(`evm/${chainId}/erc20.json`);
-    const erc20Signatures = await fetchTokens<string>(`evm/${chainId}/erc20-signatures.json`);
-    const indexTsStringified = `import tokens from "./erc20.json";
-import signatures from "./erc20-signatures.json";
-
-export default { tokens, signatures };
+    const [erc20, hash] = await fetchTokens<EVMToken[]>(`evm/${chainId}/erc20.json`);
+    const [erc20Signatures, signatureHash] = await fetchTokens<string>(
+      `evm/${chainId}/erc20-signatures.json`,
+    );
+    const indexTsStringified = `export { default as tokens } from "./erc20.json";
+export { default as signatures } from "./erc20-signatures.json";
+${hash ? `export { default as hash } from "./erc20-hash.json";` : ""}
+${signatureHash ? `export { default as signaturesHash } from "./erc20-signatures-hash.json";` : ""}
 `;
 
     if (erc20 && erc20Signatures) {
@@ -40,6 +42,16 @@ export default { tokens, signatures };
       const [coinName] = erc20[0];
       chainNames.set(chainId, coinName);
       await fs.writeFile(path.join(dirPath, "erc20.json"), JSON.stringify(erc20));
+      if (hash) {
+        await fs.writeFile(path.join(dirPath, "erc20-hash.json"), JSON.stringify(hash));
+      }
+      if (signatureHash) {
+        await fs.writeFile(
+          path.join(dirPath, "erc20-signatures-hash.json"),
+          JSON.stringify(signatureHash),
+        );
+      }
+
       await fs.writeFile(
         path.join(dirPath, "erc20-signatures.json"),
         JSON.stringify(erc20Signatures),
@@ -74,6 +86,16 @@ export const importEVMTokens = async (outputDir: string) => {
     .filter(Boolean)
     .join(";" + String.fromCharCode(10))};
 
+${supportedChainIds
+  .map(chainId =>
+    chainNames.has(chainId) &&
+    existsSync(path.join(outputDir, "evm", chainId.toString(), "erc20-hash.json"))
+      ? `import ${chainNames.get(chainId)}_tokens_hash from "./${chainId}/erc20-hash.json"`
+      : null,
+  )
+  .filter(Boolean)
+  .join(";" + String.fromCharCode(10))};
+
 ${supportedChainIds
   .map(chainId =>
     chainNames.has(chainId)
@@ -83,6 +105,18 @@ ${supportedChainIds
   .filter(Boolean)
   .join(";" + String.fromCharCode(10))};
 
+${supportedChainIds
+  .map(chainId =>
+    chainNames.has(chainId) &&
+    existsSync(path.join(outputDir, "evm", chainId.toString(), "erc20-signatures-hash.json"))
+      ? `import ${chainNames.get(
+          chainId,
+        )}_signatures_hash from "./${chainId}/erc20-signatures-hash.json"`
+      : null,
+  )
+  .filter(Boolean)
+  .join(";" + String.fromCharCode(10))};
+
 export const tokens = {
 ${supportedChainIds
   .map(chainId =>
@@ -101,9 +135,35 @@ ${supportedChainIds
   .join("," + String.fromCharCode(10))},
 };
 
+export const hashes = {
+${supportedChainIds
+  .map(chainId =>
+    chainNames.has(chainId) &&
+    existsSync(path.join(outputDir, "evm", chainId.toString(), "erc20-hash.json"))
+      ? `  ${chainId}: ${chainNames.get(chainId)}_tokens_hash`
+      : null,
+  )
+  .filter(Boolean)
+  .join("," + String.fromCharCode(10))},
+};
+
+export const signatureHashes = {
+${supportedChainIds
+  .map(chainId =>
+    chainNames.has(chainId) &&
+    existsSync(path.join(outputDir, "evm", chainId.toString(), "erc20-signatures-hash.json"))
+      ? `  ${chainId}: ${chainNames.get(chainId)}_signatures_hash`
+      : null,
+  )
+  .filter(Boolean)
+  .join("," + String.fromCharCode(10))},
+};
+
 export default {
   tokens,
   signatures,
+  hashes,
+  signatureHashes,
 };
 `;
 

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

@@ -19,10 +19,13 @@ type PolygonToken = [
 export const importPolygonTokens = async (outputDir: string) => {
   try {
     console.log("importing polygon tokens...");
-    const polygonTokens = await fetchTokens<PolygonToken[]>("polygon-erc20.json");
+    const [polygonTokens, hash] = await fetchTokens<PolygonToken[]>("polygon-erc20.json");
 
     const filePath = path.join(outputDir, "polygon-erc20");
     fs.writeFileSync(`${filePath}.json`, JSON.stringify(polygonTokens));
+    if (hash) {
+      fs.writeFileSync(`${filePath}-hash.json`, JSON.stringify(hash));
+    }
 
     const tokenTypeStringified = `export type PolygonERC20Token = [
   string, // parent currency id
@@ -44,6 +47,8 @@ export const importPolygonTokens = async (outputDir: string) => {
 
 import tokens from "./polygon-erc20.json";
 
+${hash ? `export { default as hash } from "./polygon-erc20-hash.json";` : null}
+
 export default tokens as PolygonERC20Token[];
 `,
     );

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

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

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

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