LL-7902 add polygon tokens

Author: gre

packages/cryptoassets/data/erc20-signatures.js

@@ -4,6 +4,7 @@ exports[`all USDT are countervalue enabled 1`] = `
 Array [
   "algorand/asa/312769",
   "ethereum/erc20/usd_tether__erc20_",
+  "polygon/erc20/(pos)_tether_usd",
   "tron/trc20/TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
 ]
 `;

packages/cryptoassets/data/erc20.js

@@ -1877,7 +1877,7 @@ const cryptocurrenciesById: Record<string, CryptoCurrency> = {
     managerAppName: "Polygon",
     ticker: "MATIC",
     scheme: "polygon",
-    color: "#F0B90A",
+    color: "#6d29de",
     family: "ethereum",
     ethereumLikeInfo: {
       baseChain: "mainnet",

packages/cryptoassets/data/exchange/erc20.js

@@ -4,6 +4,7 @@ import erc20tokens from "../data/erc20";
 import trc10tokens from "../data/trc10";
 import trc20tokens from "../data/trc20";
 import bep20tokens from "../data/bep20";
+import polygonTokens from "../data/polygon-erc20";
 import asatokens from "../data/asa";
 const emptyArray = [];
 const tokensArray: TokenCurrency[] = [];
@@ -15,6 +16,7 @@ const tokensByTicker: Record<string, TokenCurrency> = {};
 const tokensByAddress: Record<string, TokenCurrency> = {};
 const tokensByCurrencyAddress: Record<string, TokenCurrency> = {};
 addTokens(erc20tokens.map(convertERC20));
+addTokens(polygonTokens.map(convertERC20));
 addTokens(trc10tokens.map(convertTRONTokens("trc10")));
 addTokens(trc20tokens.map(convertTRONTokens("trc20")));
 addTokens(bep20tokens.map(convertBEP20));

packages/cryptoassets/data/polygon-erc20.js

@@ -0,0 +1,170 @@
+const invariant = require("invariant");
+const path = require("path");
+const { readFileJSON } = require("../utils");
+const {
+  findFiatCurrencyByTicker,
+} = require("../../../packages/cryptoassets/lib/fiats");
+
+// TODO in future: if we have diff network for bnb we would have to change
+const inferParentCurrency = () => "polygon";
+
+const withoutExtraComma = (str) => {
+  const m = str.match(/,+$/);
+  if (!m) return str;
+  return str.slice(0, str.length - m[0].length);
+};
+
+const WARN_IF_COUNTERVALUES = true;
+
+const lenseTicker = (a) => a[9] || a[2];
+
+module.exports = {
+  // FIXME not yet sure if it's our final path
+  paths: ["tokens/polygon/erc20"],
+  output: "data/polygon-erc20.js",
+
+  validate: (everything, countervaluesTickers) =>
+    ["polygon"].flatMap((cid) => {
+      const all = everything.filter((a) => a[0] === cid);
+      const fiatCollisions = all.filter(
+        (a) =>
+          findFiatCurrencyByTicker(lenseTicker(a)) &&
+          !a[7] &&
+          (WARN_IF_COUNTERVALUES
+            ? countervaluesTickers.includes(lenseTicker(a))
+            : true)
+      );
+      const contractGroup = {};
+      all.forEach((a) => {
+        const matches = all.filter((b) => a[6] && b[6] && a[6] === b[6]);
+        if (matches.length > 1 && !contractGroup[a[6]]) {
+          contractGroup[a[6]] = matches;
+        }
+      });
+      const groups = {};
+      all.forEach((a) => {
+        if (a[7]) return;
+        groups[lenseTicker(a)] = (groups[lenseTicker(a)] || []).concat([a]);
+      });
+      const dupTickers = Object.keys(groups).filter(
+        (a) =>
+          groups[a].length > 1 &&
+          (WARN_IF_COUNTERVALUES ? countervaluesTickers.includes(a) : true)
+      );
+
+      if (Object.keys(contractGroup).length > 0) {
+        Object.keys(contractGroup).forEach((key) => {
+          console.warn(
+            key +
+              " contract used in ERC20: " +
+              contractGroup[key].map((a) => lenseTicker(a)).join(", ")
+          );
+        });
+      }
+
+      if (fiatCollisions.length > 0) {
+        console.warn("\nPolygon ERC20 THAT COLLIDES WITH FIAT TICKERS:\n");
+        fiatCollisions.forEach((t) => {
+          console.warn(lenseTicker(t) + " ticker used by bep20: " + t[1]);
+        });
+      }
+
+      if (dupTickers.length > 0) {
+        console.warn("\nPolygon ERC20 TICKER COLLISIONS:\n");
+        dupTickers.forEach((ticker) => {
+          console.warn(
+            ticker +
+              " ticker is used by bep20: " +
+              groups[ticker].map((a) => a[1]).join(", ")
+          );
+        });
+      }
+
+      return all.filter((a) => !contractGroup[a[6]]);
+    }),
+  outputTemplate: (data) =>
+    `module.exports = [
+${data
+  .map(
+    (item) =>
+      "[" +
+      withoutExtraComma(
+        item
+          .map((value) => (value === undefined ? "" : JSON.stringify(value)))
+          .join(",")
+      ) +
+      "]"
+  )
+  .join(",\n")}
+];`,
+
+  loader: ({ signatureFolder, folder, id }) =>
+    Promise.all([
+      readFileJSON(path.join(folder, id, "common.json")),
+      readFileJSON(path.join(signatureFolder, id, "ledger_signature.json")),
+    ]).then(([common, ledgerSignature]) => {
+      const name = common.name;
+      const ticker = common.ticker.toUpperCase();
+      const magnitude = common.decimals;
+      const contractAddress = common.contract_address;
+      const parentCurrency = inferParentCurrency(common);
+      const disableCountervalue = !!common.disable_countervalue;
+      const delisted = !!common.delisted;
+      const countervalueTicker = common.countervalue_ticker;
+      try {
+        invariant(
+          typeof parentCurrency === "string" && parentCurrency,
+          "parentCurrency is required"
+        );
+        invariant(typeof name === "string" && name, "name is required");
+        invariant(typeof name === "string" && name, "name is required");
+        invariant(typeof id === "string" && id, "id is required");
+        invariant(
+          typeof ledgerSignature === "string" && ledgerSignature,
+          "ledgerSignature is required"
+        );
+        invariant(
+          ledgerSignature.length % 2 === 0 &&
+            ledgerSignature.match(/^[0-9a-fA-F]+$/g),
+          "ledgerSignature is hexa"
+        );
+        invariant(
+          typeof contractAddress === "string" && contractAddress,
+          "contractAddress is required"
+        );
+        invariant(
+          contractAddress.length === 42 &&
+            contractAddress.match(/^0x[0-9a-fA-F]+$/g),
+          "contractAddress is not eth address"
+        );
+        invariant(typeof ticker === "string" && ticker, "ticker is required");
+        invariant(
+          ticker.match(/^[0-9A-Z+_\-*$]+$/g),
+          "ticker '%s' alphanum uppercase expected",
+          ticker
+        );
+        invariant(
+          typeof magnitude === "number" &&
+            Number.isFinite(magnitude) &&
+            magnitude >= 0 &&
+            magnitude % 1 === 0,
+          "magnitude expected positive integer"
+        );
+      } catch (e) {
+        console.error("Polygon ERC20 " + id + ": " + e);
+        return null;
+      }
+      return [
+        parentCurrency,
+        id,
+        ticker,
+        magnitude,
+        name,
+        ledgerSignature,
+        contractAddress,
+        disableCountervalue,
+        delisted,
+        countervalueTicker,
+      ];
+    }),
+};

packages/cryptoassets/src/__snapshots__/currencies.test.ts.snap

@@ -8,6 +8,7 @@ const importers = [
   require("./importers/erc20full"),
   require("./importers/erc20exchange"),
   require("./importers/bep20full"),
+  require("./importers/polygontokensfull"),
   require("./importers/currenciesExchange"),
 ];