@certik/skynet 0.10.48 → 0.10.50

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.10.50
+
+- Update slack postMessage to allow passing channelId directly
+- BREAKING: Added key param for postGenieMessage
+
+## 0.10.49
+
+- Updated eth/bsc/polygon protocol to use nodereal
+
 ## 0.10.48
 
 - Fixed multiline secret production deployment bug

package/api.js

@@ -1,7 +1,7 @@
 const osModule = require("os");
 const express = require("express");
 const meow = require("meow");
-const { getJobName, getSelectorFlags, getSelectorDesc } = require("./selector");
+const { getSelectorFlags, getSelectorDesc } = require("./selector");
 const { isProduction } = require("./env");
 const { inline } = require("./log");
 

package/const.js

@@ -1,4 +1,4 @@
-const { getGetBlockApiKey, getAlchemyApiKey, getNodeRealApiKey, ensureAndGet } = require("./env");
+const { getNodeRealApiKey, ensureAndGet } = require("./env");
 
 const SKYNET_API_PREFIX = "https://api.certik-skynet.com";
 
@@ -11,8 +11,8 @@ const PROTOCOLS = {
     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",
+    endpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
+    archiveEndpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
     tokenStandard: "ERC20",
     scanApi: {
       endpoint: "https://api.etherscan.io/api",
@@ -30,7 +30,7 @@ const PROTOCOLS = {
     nativeTokenLogo: `https://token-logo.certik-assets.com/bsc:0x0000000000000000000000000000000000000000.png`,
     nativeTokenCoinGeckoId: "binance-coin",
     nativeTokenCmcId: 1839,
-    endpoint: "https://bsc-full-node.certik-skynet.com",
+    endpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
     archiveEndpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
     tokenStandard: "BEP20",
     scanApi: {
@@ -49,9 +49,9 @@ const PROTOCOLS = {
     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")}`,
+    endpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
+    archiveEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
+    backupEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
     tokenStandard: "ERC20",
     scanApi: {
       endpoint: "https://api.polygonscan.com/api",

package/env.js

@@ -14,18 +14,9 @@ function getEnvironment() {
   return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
 }
 
-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 getNodeRealApiKey(identifier) {
   // NodeReal API keys are different for each NodeReal app
-  return ensureAndGet(`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`);
+  return ensureAndGet([`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`, `SKYNET_NODEREAL_API_KEY`]);
 }
 
 function ensureAndGet(envName, defaultValue) {
@@ -69,7 +60,5 @@ module.exports = {
   getEnvironment,
   isProduction,
   isDev,
-  getGetBlockApiKey,
-  getAlchemyApiKey,
   getNodeRealApiKey,
 };

package/opsgenie.js

@@ -5,20 +5,14 @@ function getGenieKey() {
   return process.env.OPSGENIE_API_KEY;
 }
 
-function getGenieEndPoint() {
-  const key = getGenieKey();
-
-  if (!key) {
-    throw new Error("Cannot communicate with opsgenie due to missing API key: process.env.OPSGENIE_API_KEY");
-  }
-
-  return process.env.OPSGENIE_END_POINT;
+function getGenieEndPoint(key) {
+  return process.env.OPSGENIE_END_POINT || "https://api.opsgenie.com/v2/alerts";
 }
 
-async function postGenieMessage(body, verbose) {
+async function postGenieMessage(body, apiKey, verbose) {
   try {
-    const genieKey = getGenieKey();
-    const genieEndPoint = getGenieEndPoint();
+    const genieKey = apiKey || getGenieKey();
+    const genieEndPoint = getGenieEndPoint(genieKey);
 
     // Prevents duplicate alerts (See Opsgenie doc about alias)
     if (!body.alias) {

package/package.json

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

package/slack.d.ts

@@ -1,5 +1,10 @@
 import { WebClient } from "@slack/web-api";
 
+type ChannelConfig = {
+  name: string;
+  id: string;
+};
+
 export function getClient(): WebClient;
 export function findConversation(client: WebClient, name: string): Promise<string | null>;
-export function postMessage(channel: string, message: any, verbose: boolean): Promise<void>;
+export function postMessage(channel: string | ChannelConfig, message: any, verbose: boolean): Promise<void>;

package/slack.js

@@ -4,8 +4,8 @@ function getToken() {
   return process.env.SKYNET_SLACK_TOKEN;
 }
 
-function getClient() {
-  const token = getToken();
+function getClient(t) {
+  const token = t || getToken();
 
   if (!token) {
     throw new Error("Cannot communicate with slack due to missing slack token: process.env.SKYNET_SLACK_TOKEN");
@@ -49,11 +49,16 @@ async function findConversation(client, name) {
   return null;
 }
 
+function isString(s) {
+  return typeof s === "string" || s instanceof String;
+}
+
 async function postMessage(channel, message, verbose) {
   try {
-    const client = getClient();
+    const token = isString(channel) ? null : channel.token;
+    const client = getClient(token);
 
-    const conversationId = await findConversation(client, channel);
+    let conversationId = isString(channel) ? await findConversation(client, channel) : channel.id;
 
     if (!conversationId) {
       throw new Error(