@certik/skynet 0.8.6 → 0.8.10

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Changelog
 
-##0.8.6
+## 0.8.10
+
+- Improved `postMessage` in `slack` library to support private channels
+
+## 0.8.7
+
+- Changed polygon node endpoint
+
+## 0.8.6
 
 - Fixed a const.js error
+- Support more options in snowflake.js
 
-##0.8.5
+## 0.8.5
 
-- support more options in snowflake.js
+- Improved cross-OS compatibility of `detectDirectory` function
 
 ## 0.8.4
 
@@ -34,7 +43,7 @@
 
 ## 0.7.18
 
-- Added the configurability for getTokenPriceAt function in `token` library 
+- Added the configurability for getTokenPriceAt function in `token` library
 
 ## 0.7.17
 

package/cli.js

@@ -16,22 +16,24 @@ 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);
+  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
 }
 
 function detectDirectory(fullBinPath, sentinel = "package.json") {
-  const binaryNameParts = fullBinPath.split(path.sep);
+  let parentFolder = path.dirname(fullBinPath);
 
-  const parentFolders = [];
-
-  for (let i = binaryNameParts.length - 1; i > 1; i--) {
-    parentFolders.push(path.join(path.sep, ...binaryNameParts.slice(0, i)));
-  }
-
-  for (let folder of parentFolders) {
-    if (fs.existsSync(path.join(folder, sentinel))) {
-      return folder;
+  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");
@@ -40,7 +42,7 @@ function detectDirectory(fullBinPath, sentinel = "package.json") {
 function detectBin() {
   const wd = detectDirectory(process.argv[1], "package.json");
 
-  return process.argv[1].slice(wd.length + path.sep.length);
+  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
 }
 
 module.exports = {

package/const.js

@@ -1,4 +1,10 @@
-const { getEtherScanApiKey, getBscScanApiKey, getPolygonScanApiKey, getGetBlockApiKey } = require("./env");
+const {
+  getEtherScanApiKey,
+  getBscScanApiKey,
+  getPolygonScanApiKey,
+  getGetBlockApiKey,
+  getAlchemyApiKey,
+} = require("./env");
 
 const SKYNET_API_PREFIX = "https://api.certik-skynet.com";
 
@@ -42,8 +48,9 @@ const PROTOCOLS = {
     nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
     nativeTokenLogo: `https://token-logo.certik-assets.com/polygon:0x0000000000000000000000000000000000000000.png`,
     nativeTokenCoinGeckoId: "matic-network",
-    endpoint: `https://matic.getblock.io/mainnet/?api_key=${getGetBlockApiKey()}`,
-    archiveEndpoint: `https://matic.getblock.io/mainnet/?api_key=${getGetBlockApiKey()}`,
+    endpoint: `https://polygon-mainnet.g.alchemy.com/v2/${getAlchemyApiKey("POLYGON")}`,
+    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",

package/env.js

@@ -30,6 +30,11 @@ function getGetBlockApiKey() {
   return ensureAndGet("SKYNET_GETBLOCK_API_KEY");
 }
 
+function getAlchemyApiKey(identifier) {
+  // Alchemy API keys are different for each alchemy app
+  return ensureAndGet(`SKYNET_ALCHEMY_API_${identifier.toUpperCase()}_KEY`);
+}
+
 function ensureAndGet(envName, defaultValue) {
   if (Array.isArray(envName)) {
     for (let name of envName) {
@@ -75,4 +80,5 @@ module.exports = {
   getBscScanApiKey,
   getPolygonScanApiKey,
   getGetBlockApiKey,
+  getAlchemyApiKey,
 };

package/indexer.js

@@ -539,7 +539,12 @@ ${getSelectorDesc(selector)}
 
     async function runBuild({ verbose, ...selectorFlags }) {
       const startTime = Date.now();
-      console.log(`[INDEXER] starting build, ${toSelectorString(selectorFlags, ", ")}`);
+
+      if (Object.keys(selectorFlags).length > 0) {
+        console.log(`[INDEXER] starting build, ${toSelectorString(selectorFlags, ", ")}`);
+      } else {
+        console.log(`[INDEXER] starting build`);
+      }
 
       const result = await exponentialRetry(
         async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@certik/skynet",
-  "version": "0.8.6",
+  "version": "0.8.10",
   "description": "Skynet Shared JS library",
   "main": "index.js",
   "author": "CertiK Engineering",

package/scan.js

@@ -1,12 +1,12 @@
-const { exponentialRetry, wait } = require("@certik/skynet/availability");
-const { PROTOCOLS } = require("@certik/skynet/const");
+const { exponentialRetry, wait } = require("./availability");
+const { PROTOCOLS } = require("./const");
 const fetch = require("node-fetch");
 
 const BATCH_SIZE = 10_000; // Max number of transactions fetched from scan api at once
 
-function getScanApiEndpoint(protocol, addr, startBlock = 0, endBlock = null) {
+function getScanApiEndpoint(protocol, addr, startBlock = 0, endBlock = null, offset=BATCH_SIZE) {
   const { endpoint, key } = PROTOCOLS[protocol].scanApi;
-  let url = `${endpoint}?module=account&action=txlist&address=${addr}&apikey=${key}&sort=asc&startblock=${startBlock}&page=1&offset=${BATCH_SIZE}`;
+  let url = `${endpoint}?module=account&action=txlist&address=${addr}&apikey=${key}&sort=asc&startblock=${startBlock}&page=1&offset=${offset}`;
 
   if (endBlock) {
     url += `&endblock=${endBlock}`;
@@ -15,19 +15,25 @@ function getScanApiEndpoint(protocol, addr, startBlock = 0, endBlock = null) {
   return url;
 }
 
-async function fetchTxs(protocol, addr, startBlock, to, verbose) {
-  const url = getScanApiEndpoint(protocol, addr, startBlock, to);
+async function fetchTxs(protocol, addr, since, to, offset) {
+  const url = getScanApiEndpoint(protocol, addr, since, to, offset);
 
+  try {
+    const res = await fetch(url);
+    const scanJSON = await res.json();
+    return scanJSON.result;
+  } catch (err) {
+    console.log(`error fetching txs: ${err}`)
+    return null;
+  }
+}
+
+async function fetchTxsWithRetry(protocol, addr, since, to, offset, verbose) {
   const txs = await exponentialRetry(
-    async () => {
-      const res = await fetch(url);
-      const scanJSON = await res.json();
-      return scanJSON.result;
-    },
+    async () => fetchTxs(protocol, addr, since, to, offset),
     { maxRetry: 6, test: Array.isArray, verbose }
   )
 
-  console.log(`start block=${startBlock}, total items=${txs.length}`);
   return txs;
 }
 
@@ -39,7 +45,8 @@ async function streamTxs(address, since, to, callback, verbose) {
   const [protocol, addr] = address.split(":");
 
   while (hasMorePage) {
-    const txs = await fetchTxs(protocol, addr, startBlock, to, verbose);
+    const txs = await fetchTxs(protocol, addr, startBlock, to, BATCH_SIZE, verbose);
+    console.log(`start block=${since}, total items=${txs.length}`);
 
     // This will only ever happen if the total number of txs is a multiple of our batch size
     if (txs.length === 0) {
@@ -65,4 +72,4 @@ async function streamTxs(address, since, to, callback, verbose) {
   }
 }
 
-module.exports = { streamTxs };
+module.exports = { streamTxs, fetchTxs, fetchTxsWithRetry };

package/slack.js

@@ -19,12 +19,26 @@ function getClient() {
 async function findConversation(client, name) {
   const { conversations } = client;
 
-  // Call the conversations.list method using the built-in WebClient
+  let channels = [];
+
   let result = await conversations.list({
+    types: "public_channel,private_channel",
     limit: 1000,
   });
 
-  for (const channel of result.channels) {
+  channels = channels.concat(result.channels);
+
+  while (result.response_metadata.next_cursor) {
+    result = await conversations.list({
+      types: "public_channel,private_channel",
+      cursor: result.response_metadata.next_cursor,
+      limit: 1000,
+    });
+
+    channels = channels.concat(result.channels);
+  }
+
+  for (const channel of channels) {
     if (channel.name === name) {
       const conversationId = channel.id;
 
@@ -41,6 +55,12 @@ async function postMessage(channel, message, verbose) {
 
     const conversationId = await findConversation(client, channel);
 
+    if (!conversationId) {
+      throw new Error(
+        `cannot find slack public/private channel: ${channel}, you may have to invite the @CertiK Skynet bot to the channel`
+      );
+    }
+
     let post = {};
 
     if (typeof message === "string") {
@@ -58,9 +78,10 @@ async function postMessage(channel, message, verbose) {
       ...post,
     });
   } catch (error) {
-    // no blocking
     console.error("failed to post slack message", error);
+
+    throw error;
   }
 }
 
-module.exports = { postMessage };
+module.exports = { getClient, findConversation, postMessage };