@certik/skynet 0.10.6 → 0.10.7

package/availability.js

@@ -1,58 +1,58 @@
-async function wait(time) {
-  return new Promise(resolve => {
-    setTimeout(resolve, time);
-  });
-}
-
-async function retry(times, verbose, func) {
-  try {
-    await func();
-  } catch (err) {
-    if (times <= 1) {
-      console.log("failed to retry", err);
-      throw err;
-    } else {
-      if (verbose) {
-        console.log("retry catch error", err);
-        console.log("retrying remaining times=", times - 1);
-      }
-      await wait(5000);
-      await retry(times - 1, verbose, func);
-    }
-  }
-}
-
-async function exponentialRetry(
-  func,
-  { maxRetry, initialDuration, growFactor, test, verbose }
-) {
-  let retries = maxRetry;
-  let duration = initialDuration || 5000;
-  let growFactorFinal = growFactor || 2;
-
-  let result = await func();
-
-  while (!test(result) && retries > 0) {
-    if (verbose) {
-      console.log("failed attempt result", result);
-    }
-
-    console.log(
-      `sleep for ${duration}s after failed attempt, remaining ${retries} attempts`
-    );
-    retries = retries - 1;
-
-    await wait(duration);
-
-    result = await func();
-    duration = duration * growFactorFinal;
-  }
-
-  return result;
-}
-
-module.exports = {
-  wait,
-  retry,
-  exponentialRetry
-};
+async function wait(time) {
+  return new Promise(resolve => {
+    setTimeout(resolve, time);
+  });
+}
+
+async function retry(times, verbose, func) {
+  try {
+    await func();
+  } catch (err) {
+    if (times <= 1) {
+      console.log("failed to retry", err);
+      throw err;
+    } else {
+      if (verbose) {
+        console.log("retry catch error", err);
+        console.log("retrying remaining times=", times - 1);
+      }
+      await wait(5000);
+      await retry(times - 1, verbose, func);
+    }
+  }
+}
+
+async function exponentialRetry(
+  func,
+  { maxRetry, initialDuration, growFactor, test, verbose }
+) {
+  let retries = maxRetry;
+  let duration = initialDuration || 5000;
+  let growFactorFinal = growFactor || 2;
+
+  let result = await func();
+
+  while (!test(result) && retries > 0) {
+    if (verbose) {
+      console.log("failed attempt result", result);
+    }
+
+    console.log(
+      `sleep for ${duration}s after failed attempt, remaining ${retries} attempts`
+    );
+    retries = retries - 1;
+
+    await wait(duration);
+
+    result = await func();
+    duration = duration * growFactorFinal;
+  }
+
+  return result;
+}
+
+module.exports = {
+  wait,
+  retry,
+  exponentialRetry
+};

package/block.js

@@ -1,83 +1,83 @@
-const { getEnvironment } = require("./env");
-const { PROTOCOLS } = require("./const");
-const { readFile } = require("./s3");
-const { getRecordByKey } = require("./dynamodb");
-const fetch = require("node-fetch");
-const Web3 = require("web3");
-
-const S3_BUCKET_NAME =
-  getEnvironment() === "prd" ? "certik-skynet" : "certik-skynet-dev";
-const INDEXER_STATE_TABLE = `skynet-${getEnvironment()}-indexer-state`;
-
-function leftPad3(num) {
-  if (num === 0) {
-    return "000";
-  } else if (num < 10) {
-    return "00" + String(num);
-  } else if (num < 100) {
-    return "0" + String(num);
-  } else {
-    return String(num);
-  }
-}
-
-function getBlockS3Path(protocol, height) {
-  return `chaindata/${protocol}/${Math.floor(height / 1_000_000)}/${leftPad3(
-    Math.floor(height / 1_000) % 1000
-  )}/${leftPad3(height % 1000)}.json`;
-}
-
-// We use this function instead of web3 because the gas limits on bsc exceed
-// the size supported by javascript numbers, and web3 does not support this
-async function getBlock(protocol, height) {
-  const body = {
-    jsonrpc: "2.0",
-    method: "eth_getBlockByNumber",
-    params: [`0x${height.toString(16)}`, true],
-    id: 1
-  };
-  const response = await fetch(PROTOCOLS[protocol].endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-
-  const { result: block } = await response.json();
-
-  return block;
-}
-
-async function getLatestBlockHeight(protocol) {
-  const web3 = new Web3(PROTOCOLS[protocol].endpoint);
-  const isSyncing = await web3.eth.isSyncing();
-
-  if (isSyncing) {
-    return isSyncing.currentBlock;
-  } else {
-    const latestBlock = await web3.eth.getBlock("latest");
-
-    return latestBlock.number;
-  }
-}
-
-async function getLatestS3BlockHeight(protocol) {
-  const name = `AMLBlockIndexerSince(protocol=${protocol})`;
-  const { value: height } = await getRecordByKey(INDEXER_STATE_TABLE, { name });
-  return height;
-}
-
-async function getBlockFromS3(protocol, height) {
-  const body = await readFile(S3_BUCKET_NAME, getBlockS3Path(protocol, height));
-
-  return JSON.parse(body);
-}
-
-module.exports = {
-  getLatestBlockHeight,
-  getBlock,
-  getBlockS3Path,
-  getLatestS3BlockHeight,
-  getBlockFromS3
-};
+const { getEnvironment } = require("./env");
+const { PROTOCOLS } = require("./const");
+const { readFile } = require("./s3");
+const { getRecordByKey } = require("./dynamodb");
+const fetch = require("node-fetch");
+const Web3 = require("web3");
+
+const S3_BUCKET_NAME =
+  getEnvironment() === "prd" ? "certik-skynet" : "certik-skynet-dev";
+const INDEXER_STATE_TABLE = `skynet-${getEnvironment()}-indexer-state`;
+
+function leftPad3(num) {
+  if (num === 0) {
+    return "000";
+  } else if (num < 10) {
+    return "00" + String(num);
+  } else if (num < 100) {
+    return "0" + String(num);
+  } else {
+    return String(num);
+  }
+}
+
+function getBlockS3Path(protocol, height) {
+  return `chaindata/${protocol}/${Math.floor(height / 1_000_000)}/${leftPad3(
+    Math.floor(height / 1_000) % 1000
+  )}/${leftPad3(height % 1000)}.json`;
+}
+
+// We use this function instead of web3 because the gas limits on bsc exceed
+// the size supported by javascript numbers, and web3 does not support this
+async function getBlock(protocol, height) {
+  const body = {
+    jsonrpc: "2.0",
+    method: "eth_getBlockByNumber",
+    params: [`0x${height.toString(16)}`, true],
+    id: 1
+  };
+  const response = await fetch(PROTOCOLS[protocol].endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+
+  const { result: block } = await response.json();
+
+  return block;
+}
+
+async function getLatestBlockHeight(protocol) {
+  const web3 = new Web3(PROTOCOLS[protocol].endpoint);
+  const isSyncing = await web3.eth.isSyncing();
+
+  if (isSyncing) {
+    return isSyncing.currentBlock;
+  } else {
+    const latestBlock = await web3.eth.getBlock("latest");
+
+    return latestBlock.number;
+  }
+}
+
+async function getLatestS3BlockHeight(protocol) {
+  const name = `AMLBlockIndexerSince(protocol=${protocol})`;
+  const { value: height } = await getRecordByKey(INDEXER_STATE_TABLE, { name });
+  return height;
+}
+
+async function getBlockFromS3(protocol, height) {
+  const body = await readFile(S3_BUCKET_NAME, getBlockS3Path(protocol, height));
+
+  return JSON.parse(body);
+}
+
+module.exports = {
+  getLatestBlockHeight,
+  getBlock,
+  getBlockS3Path,
+  getLatestS3BlockHeight,
+  getBlockFromS3
+};

package/cli.js

@@ -1,53 +1,53 @@
-const path = require("path");
-const fs = require("fs");
-
-function getBinaryName() {
-  const binaryNameParts = process.argv[1].split(path.sep);
-  const binaryName = binaryNameParts[binaryNameParts.length - 1];
-
-  return binaryName;
-}
-
-function detectSkynetDirectory() {
-  return detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-}
-
-function detectWorkingDirectory() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-  const skynetd = detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
-
-  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
-}
-
-function detectDirectory(fullBinPath, sentinel = "package.json") {
-  let parentFolder = path.dirname(fullBinPath);
-
-  while (parentFolder) {
-    // check if parentFolder length is greater than 0
-    const sentinelPath = path.join(parentFolder, sentinel);
-    if (fs.existsSync(sentinelPath)) {
-      return parentFolder;
-    }
-    const newParentFolder = path.dirname(parentFolder);
-    if (newParentFolder === parentFolder) {
-      // we have reached the root folder
-      break;
-    }
-    parentFolder = newParentFolder;
-  }
-
-  throw new Error("Cannot detect current working directory");
-}
-
-function detectBin() {
-  const wd = detectDirectory(process.argv[1], "package.json");
-
-  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
-}
-
-module.exports = {
-  getBinaryName,
-  detectSkynetDirectory,
-  detectWorkingDirectory,
-  detectBin,
-};
+const path = require("path");
+const fs = require("fs");
+
+function getBinaryName() {
+  const binaryNameParts = process.argv[1].split(path.sep);
+  const binaryName = binaryNameParts[binaryNameParts.length - 1];
+
+  return binaryName;
+}
+
+function detectSkynetDirectory() {
+  return detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
+}
+
+function detectWorkingDirectory() {
+  const wd = detectDirectory(process.argv[1], "package.json");
+  const skynetd = detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
+
+  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
+}
+
+function detectDirectory(fullBinPath, sentinel = "package.json") {
+  let parentFolder = path.dirname(fullBinPath);
+
+  while (parentFolder) {
+    // check if parentFolder length is greater than 0
+    const sentinelPath = path.join(parentFolder, sentinel);
+    if (fs.existsSync(sentinelPath)) {
+      return parentFolder;
+    }
+    const newParentFolder = path.dirname(parentFolder);
+    if (newParentFolder === parentFolder) {
+      // we have reached the root folder
+      break;
+    }
+    parentFolder = newParentFolder;
+  }
+
+  throw new Error("Cannot detect current working directory");
+}
+
+function detectBin() {
+  const wd = detectDirectory(process.argv[1], "package.json");
+
+  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
+}
+
+module.exports = {
+  getBinaryName,
+  detectSkynetDirectory,
+  detectWorkingDirectory,
+  detectBin,
+};

package/const.js

@@ -1,92 +1,92 @@
-const {
-  getEtherScanApiKey,
-  getBscScanApiKey,
-  getPolygonScanApiKey,
-  getGetBlockApiKey,
-  getAlchemyApiKey,
-  getNodeRealApiKey,
-} = require("./env");
-
-const SKYNET_API_PREFIX = "https://api.certik-skynet.com";
-
-const PROTOCOLS = {
-  eth: {
-    nativeTokenName: "Ethereum",
-    nativeTokenSymbol: "ETH",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "eth:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://token-logo.certik-assets.com/eth:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "ethereum",
-    nativeTokenCmcId: 1027,
-    endpoint: "https://eth-full-node.certik-skynet.com",
-    archiveEndpoint: "https://eth-node.certik-skynet.com",
-    tokenStandard: "ERC20",
-    scanApi: {
-      endpoint: "https://api.etherscan.io/api",
-      key: getEtherScanApiKey(),
-    },
-    multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
-    scanUrl: "https://etherscan.io/",
-  },
-  bsc: {
-    nativeTokenName: "Binance Coin",
-    nativeTokenSymbol: "BNB",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "bsc:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://token-logo.certik-assets.com/bsc:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "binance-coin",
-    nativeTokenCmcId: 1839,
-    endpoint: "https://bsc-full-node.certik-skynet.com",
-    archiveEndpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
-    tokenStandard: "BEP20",
-    scanApi: {
-      endpoint: "https://api.bscscan.com/api",
-      key: getBscScanApiKey(),
-    },
-    multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
-    scanUrl: "https://bscscan.com/",
-  },
-  polygon: {
-    nativeTokenName: "Polygon",
-    nativeTokenSymbol: "MATIC",
-    nativeTokenDecimals: 18,
-    nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
-    nativeTokenLogo: `https://token-logo.certik-assets.com/polygon:0x0000000000000000000000000000000000000000.png`,
-    nativeTokenCoinGeckoId: "matic-network",
-    nativeTokenCmcId: 3890,
-    endpoint: `https://poly-full-node.certik-skynet.com`,
-    backupEndpoint: `https://matic.getblock.io/mainnet/?api_key=${getGetBlockApiKey()}`,
-    archiveEndpoint: `https://polygon-mainnet.g.alchemy.com/v2/${getAlchemyApiKey("POLYGON")}`,
-    tokenStandard: "ERC20",
-    scanApi: {
-      endpoint: "https://api.polygonscan.com/api",
-      key: getPolygonScanApiKey(),
-    },
-    multiCallProvider: "0x8eC86392e0aDB57d00fDffbA39b8870e107c0757",
-    scanUrl: "https://polygonscan.com/",
-  },
-};
-
-const TIME = {
-  BY_MS: {
-    SECOND: 1000,
-    MINUTE: 1000 * 60,
-    HOUR: 1000 * 60 * 60,
-    DAY: 1000 * 60 * 60 * 24,
-    WEEK: 1000 * 60 * 60 * 24 * 7,
-    YEAR: 1000 * 60 * 60 * 24 * 365,
-  },
-  BY_S: {
-    MINUTE: 60,
-    HOUR: 60 * 60,
-    DAY: 60 * 60 * 24,
-    WEEK: 60 * 60 * 24 * 7,
-    YEAR: 60 * 60 * 24 * 365,
-  },
-};
-
-module.exports = {
-  SKYNET_API_PREFIX,
-  PROTOCOLS,
-  TIME,
-};
+const {
+  getEtherScanApiKey,
+  getBscScanApiKey,
+  getPolygonScanApiKey,
+  getGetBlockApiKey,
+  getAlchemyApiKey,
+  getNodeRealApiKey,
+} = require("./env");
+
+const SKYNET_API_PREFIX = "https://api.certik-skynet.com";
+
+const PROTOCOLS = {
+  eth: {
+    nativeTokenName: "Ethereum",
+    nativeTokenSymbol: "ETH",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "eth:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://token-logo.certik-assets.com/eth:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "ethereum",
+    nativeTokenCmcId: 1027,
+    endpoint: "https://eth-full-node.certik-skynet.com",
+    archiveEndpoint: "https://eth-node.certik-skynet.com",
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.etherscan.io/api",
+      key: getEtherScanApiKey(),
+    },
+    multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
+    scanUrl: "https://etherscan.io/",
+  },
+  bsc: {
+    nativeTokenName: "Binance Coin",
+    nativeTokenSymbol: "BNB",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "bsc:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://token-logo.certik-assets.com/bsc:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "binance-coin",
+    nativeTokenCmcId: 1839,
+    endpoint: "https://bsc-full-node.certik-skynet.com",
+    archiveEndpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
+    tokenStandard: "BEP20",
+    scanApi: {
+      endpoint: "https://api.bscscan.com/api",
+      key: getBscScanApiKey(),
+    },
+    multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
+    scanUrl: "https://bscscan.com/",
+  },
+  polygon: {
+    nativeTokenName: "Polygon",
+    nativeTokenSymbol: "MATIC",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://token-logo.certik-assets.com/polygon:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "matic-network",
+    nativeTokenCmcId: 3890,
+    endpoint: `https://poly-full-node.certik-skynet.com`,
+    backupEndpoint: `https://matic.getblock.io/mainnet/?api_key=${getGetBlockApiKey()}`,
+    archiveEndpoint: `https://polygon-mainnet.g.alchemy.com/v2/${getAlchemyApiKey("POLYGON")}`,
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.polygonscan.com/api",
+      key: getPolygonScanApiKey(),
+    },
+    multiCallProvider: "0x8eC86392e0aDB57d00fDffbA39b8870e107c0757",
+    scanUrl: "https://polygonscan.com/",
+  },
+};
+
+const TIME = {
+  BY_MS: {
+    SECOND: 1000,
+    MINUTE: 1000 * 60,
+    HOUR: 1000 * 60 * 60,
+    DAY: 1000 * 60 * 60 * 24,
+    WEEK: 1000 * 60 * 60 * 24 * 7,
+    YEAR: 1000 * 60 * 60 * 24 * 365,
+  },
+  BY_S: {
+    MINUTE: 60,
+    HOUR: 60 * 60,
+    DAY: 60 * 60 * 24,
+    WEEK: 60 * 60 * 24 * 7,
+    YEAR: 60 * 60 * 24 * 365,
+  },
+};
+
+module.exports = {
+  SKYNET_API_PREFIX,
+  PROTOCOLS,
+  TIME,
+};