@certik/skynet 0.8.14 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.9.0
+
+- Added `web3` library with call support
+
+## 0.8.16
+
+- Changed monitor exit behavior
+- Improved OpsGenie message for service checks
+
+## 0.8.15
+
+- Fixed OpsGenie message bug 
+
 ## 0.8.14
 
 - Switched monitor to send to opsgenie only

package/abi.js

@@ -6,35 +6,35 @@ const ERC20 = [
     outputs: [
       {
         name: "",
-        type: "string"
-      }
+        type: "string",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     constant: false,
     inputs: [
       {
         name: "_spender",
-        type: "address"
+        type: "address",
       },
       {
         name: "_value",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     name: "approve",
     outputs: [
       {
         name: "",
-        type: "bool"
-      }
+        type: "bool",
+      },
     ],
     payable: false,
     stateMutability: "nonpayable",
-    type: "function"
+    type: "function",
   },
   {
     constant: true,
@@ -43,39 +43,39 @@ const ERC20 = [
     outputs: [
       {
         name: "",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     constant: false,
     inputs: [
       {
         name: "_from",
-        type: "address"
+        type: "address",
       },
       {
         name: "_to",
-        type: "address"
+        type: "address",
       },
       {
         name: "_value",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     name: "transferFrom",
     outputs: [
       {
         name: "",
-        type: "bool"
-      }
+        type: "bool",
+      },
     ],
     payable: false,
     stateMutability: "nonpayable",
-    type: "function"
+    type: "function",
   },
   {
     constant: true,
@@ -84,31 +84,31 @@ const ERC20 = [
     outputs: [
       {
         name: "",
-        type: "uint8"
-      }
+        type: "uint8",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     constant: true,
     inputs: [
       {
         name: "_owner",
-        type: "address"
-      }
+        type: "address",
+      },
     ],
     name: "balanceOf",
     outputs: [
       {
         name: "balance",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     constant: true,
@@ -117,63 +117,63 @@ const ERC20 = [
     outputs: [
       {
         name: "",
-        type: "string"
-      }
+        type: "string",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     constant: false,
     inputs: [
       {
         name: "_to",
-        type: "address"
+        type: "address",
       },
       {
         name: "_value",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     name: "transfer",
     outputs: [
       {
         name: "",
-        type: "bool"
-      }
+        type: "bool",
+      },
     ],
     payable: false,
     stateMutability: "nonpayable",
-    type: "function"
+    type: "function",
   },
   {
     constant: true,
     inputs: [
       {
         name: "_owner",
-        type: "address"
+        type: "address",
       },
       {
         name: "_spender",
-        type: "address"
-      }
+        type: "address",
+      },
     ],
     name: "allowance",
     outputs: [
       {
         name: "",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     payable: false,
     stateMutability: "view",
-    type: "function"
+    type: "function",
   },
   {
     payable: true,
     stateMutability: "payable",
-    type: "fallback"
+    type: "fallback",
   },
   {
     anonymous: false,
@@ -181,21 +181,21 @@ const ERC20 = [
       {
         indexed: true,
         name: "owner",
-        type: "address"
+        type: "address",
       },
       {
         indexed: true,
         name: "spender",
-        type: "address"
+        type: "address",
       },
       {
         indexed: false,
         name: "value",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     name: "Approval",
-    type: "event"
+    type: "event",
   },
   {
     anonymous: false,
@@ -203,25 +203,151 @@ const ERC20 = [
       {
         indexed: true,
         name: "from",
-        type: "address"
+        type: "address",
       },
       {
         indexed: true,
         name: "to",
-        type: "address"
+        type: "address",
       },
       {
         indexed: false,
         name: "value",
-        type: "uint256"
-      }
+        type: "uint256",
+      },
     ],
     name: "Transfer",
-    type: "event"
-  }
+    type: "event",
+  },
+];
+
+const MULTICALL = [
+  {
+    inputs: [{ internalType: "address", name: "_addr", type: "address" }],
+    name: "callBalanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callBlockNumber",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_i", type: "uint256" }],
+    name: "callBlockhash",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callChainId",
+    outputs: [{ internalType: "uint256", name: "id", type: "uint256" }],
+    stateMutability: "pure",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "_addr", type: "address" }],
+    name: "callCode",
+    outputs: [{ internalType: "bytes", name: "code", type: "bytes" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "_addr", type: "address" }],
+    name: "callCodeHash",
+    outputs: [{ internalType: "bytes32", name: "codeHash", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "_addr", type: "address" }],
+    name: "callCodeSize",
+    outputs: [{ internalType: "uint256", name: "size", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callCoinbase",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callDifficulty",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callGasLeft",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callGasLimit",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callGasPrice",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callOrigin",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "callTimestamp",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "bool", name: "delegateCall", type: "bool" },
+          { internalType: "bool", name: "revertOnError", type: "bool" },
+          { internalType: "uint256", name: "gasLimit", type: "uint256" },
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "uint256", name: "value", type: "uint256" },
+          { internalType: "bytes", name: "data", type: "bytes" },
+        ],
+        internalType: "struct IModuleCalls.Transaction[]",
+        name: "_txs",
+        type: "tuple[]",
+      },
+    ],
+    name: "multiCall",
+    outputs: [
+      { internalType: "bool[]", name: "_successes", type: "bool[]" },
+      { internalType: "bytes[]", name: "_results", type: "bytes[]" },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
 ];
 
 module.exports = {
+  MULTICALL,
   ERC20,
-  BEP20: ERC20
+  BEP20: ERC20,
 };

package/app.js

@@ -202,8 +202,7 @@ function indexer({ name, selector, build, check, env = {}, region = "us-east-1"
           bin: `${bin} check`,
           schedule: check.schedule,
           cpu: check.cpu || 100,
-          mem: check.mem || 100,
-          hasSlack: check.slackChannel,
+          mem: check.mem || 100
         },
       });
 
@@ -216,8 +215,7 @@ function indexer({ name, selector, build, check, env = {}, region = "us-east-1"
         type: "stateless",
         selector,
         check: check.func,
-        maxRetry: check.maxRetry,
-        slackChannel: check.slackChannel,
+        maxRetry: check.maxRetry
       });
 
       monitor();
@@ -317,8 +315,7 @@ function modeIndexer({ name, selector, state, build, validate, check, env = {},
           bin: `${bin} check`,
           schedule: check.schedule,
           cpu: check.cpu || 100,
-          mem: check.mem || 100,
-          hasSlack: check.slackChannel,
+          mem: check.mem || 100
         },
       });
 
@@ -332,8 +329,7 @@ function modeIndexer({ name, selector, state, build, validate, check, env = {},
         selector,
         mode: true,
         check: check.func,
-        maxRetry: check.maxRetry,
-        slackChannel: check.slackChannel,
+        maxRetry: check.maxRetry
       });
 
       monitor();
@@ -421,8 +417,7 @@ function producer({ name, selector, produce, check, state, env = {}, region = "u
           bin: `${bin} check`,
           schedule: check.schedule,
           cpu: check.cpu || 100,
-          mem: check.mem || 100,
-          hasSlack: check.slackChannel,
+          mem: check.mem || 100
         },
       });
 
@@ -435,8 +430,7 @@ function producer({ name, selector, produce, check, state, env = {}, region = "u
         type: "stateful",
         selector,
         check: check.func,
-        maxRetry: check.maxRetry,
-        slackChannel: check.slackChannel,
+        maxRetry: check.maxRetry
       });
 
       monitor();
@@ -515,8 +509,7 @@ function consumer({ name, selector, consume, check, env = {}, region = "us-east-
           bin: `${bin} check`,
           schedule: check.schedule,
           cpu: check.cpu || 100,
-          mem: check.mem || 100,
-          hasSlack: check.slackChannel,
+          mem: check.mem || 100
         },
       });
 
@@ -529,8 +522,7 @@ function consumer({ name, selector, consume, check, env = {}, region = "us-east-
         type: "stateless",
         selector,
         check: check.func,
-        maxRetry: check.maxRetry,
-        slackChannel: check.slackChannel,
+        maxRetry: check.maxRetry
       });
 
       monitor();

package/const.js

@@ -23,6 +23,7 @@ const PROTOCOLS = {
       endpoint: "https://api.etherscan.io/api",
       key: getEtherScanApiKey(),
     },
+    multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
     scanUrl: "https://etherscan.io/",
   },
   bsc: {
@@ -39,6 +40,7 @@ const PROTOCOLS = {
       endpoint: "https://api.bscscan.com/api",
       key: getBscScanApiKey(),
     },
+    multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
     scanUrl: "https://bscscan.com/",
   },
   polygon: {
@@ -56,8 +58,9 @@ const PROTOCOLS = {
       endpoint: "https://api.polygonscan.com/api",
       key: getPolygonScanApiKey(),
     },
+    multiCallProvider: "", // TODO
     scanUrl: "https://polygonscan.com/",
-  },
+  }
 };
 
 const TIME = {

package/monitor.js

@@ -4,9 +4,8 @@ const { getSelectorFlags, getSelectorDesc, toSelectorString } = require("./selec
 const { getBinaryName } = require("./cli");
 const { exponentialRetry } = require("./availability");
 const { getIndexerLatestId, getIndexerValidatedId, getIndexerState } = require("./indexer");
-const { postMessage } = require("./slack");
 const { postGenieMessage } = require("./opsgenie");
-const { getJobName, getNomadAddr } = require("./deploy");
+const { getJobName } = require("./deploy");
 
 const ERROR_LEVEL = {
   INFO: "Info",
@@ -31,70 +30,44 @@ function sortErrors(errors) {
 }
 
 async function getMostRecentJobLaunch(name) {
-  const jobsRes = await fetch(`http://localhost:4646/v1/jobs?prefix=${name}`);
+  try {
+    const jobsRes = await fetch(`http://localhost:4646/v1/jobs?prefix=${name}`);
 
-  if (!jobsRes.ok) {
-    console.log(`[MONITOR] request local nomad API failed`);
+    if (!jobsRes.ok) {
+      console.log(`[MONITOR] request local nomad API failed`);
 
-    return null;
-  }
-
-  const jobs = await jobsRes.json();
-
-  if (jobs.length === 0) {
-    console.log(`[MONITOR] did not see any jobs prefixed with ${name}`);
-
-    return null;
-  }
+      return null;
+    }
 
-  const recentFinishedJob = jobs.reverse().find((job) => {
-    // filter out monitor job
-    return job.ID.indexOf("-monitor") === -1 && job.Status === "dead";
-  });
+    const jobs = await jobsRes.json();
 
-  if (!recentFinishedJob) {
-    console.log(`[MONITOR] did not see any dead jobs`);
+    if (jobs.length === 0) {
+      console.log(`[MONITOR] did not see any jobs prefixed with ${name}`);
 
-    return null;
-  }
+      return null;
+    }
 
-  console.log("[MONITOR]", "most recent job info", recentFinishedJob.ID, recentFinishedJob.JobSummary.Summary);
+    const recentFinishedJob = jobs.reverse().find((job) => {
+      // filter out monitor job
+      return job.ID.indexOf("-monitor") === -1 && job.Status === "dead";
+    });
 
-  return recentFinishedJob;
-}
+    if (!recentFinishedJob) {
+      console.log(`[MONITOR] did not see any dead jobs`);
 
-function checkMostRecentJobFailures(recentFinishedJob) {
-  if (!recentFinishedJob) {
-    return [];
-  }
+      return null;
+    }
 
-  const summary = recentFinishedJob.JobSummary.Summary;
-  const groups = Object.keys(summary);
+    console.log("[MONITOR]", "most recent job info", recentFinishedJob.ID, recentFinishedJob.JobSummary.Summary);
 
-  for (let group of groups) {
-    if (summary[group].Failed > 0) {
-      return [
-        {
-          type: ERROR_LEVEL.CRITICAL,
-          message: `The most recent launch returned non-zero exit value, please investigate`,
-        },
-      ];
-    }
+    return recentFinishedJob;
+  } catch (getJobError) {
+    console.log("[MONITOR]", "cannot get most recent job", getJobError.message);
+    return null;
   }
-
-  return [];
 }
 
-function createMonitor({
-  binaryName,
-  name,
-  type = "stateless",
-  mode = false,
-  slackChannel,
-  selector = {},
-  check,
-  maxRetry = 2,
-}) {
+function createMonitor({ binaryName, name, type = "stateless", mode = false, selector = {}, check, maxRetry = 2 }) {
   function monitor() {
     if (!binaryName) {
       binaryName = getBinaryName();
@@ -171,22 +144,26 @@ ${
 
       const jobName = getJobName(name, selectorFlags, mode);
       const mostRecentJob = await getMostRecentJobLaunch(jobName);
-      const recentJobFailures = checkMostRecentJobFailures(mostRecentJob);
-
-      result = result.concat(recentJobFailures);
 
       if (result.length > 0) {
         console.log("Found Errors", result);
 
         if (production) {
-          // Also alert on opsgenie (func prevents duplicate alerts)
+          const nomadAddr = process.env.SKYNET_NOMAD_PRODUCTION_ADDR;
+
+          // alert on opsgenie
           await postGenieMessage(
-            `${jobName} Monitor Errors: ${result.map((m) => m.message || m).join("\n")}`,
-            m.message
+            `Failed Service Check: ${jobName}`,
+            `<p><b>Service:</b><a href="${nomadAddr}/ui/jobs/${jobName}" target="_blank">${jobName}</a></p><p><b>Issues</b></p><ul>${sortErrors(
+              result
+            )
+              .map((m) => `<li><b>${m.type}:</b> ${m.message}</li>`)
+              .join("")}</ul>`,
+            verbose
           );
+        } else {
+          console.log("skip sending messages to opsgenie in dev env");
         }
-
-        throw new Error(`failed due to critical errors`);
       }
 
       console.log(`[MONITOR] check successfully in ${Date.now() - startTime}ms`);
@@ -212,4 +189,4 @@ ${
   return { monitor };
 }
 
-module.exports = { createMonitor, ERROR_LEVEL };
+module.exports = { createMonitor, ERROR_LEVEL, LEVEL_EMOJI };

package/opsgenie.js

@@ -26,7 +26,7 @@ async function postGenieMessage(msg, desc, verbose) {
     };
 
     // Prevents duplicate alerts (See Opsgenie doc about alias)
-    bodyHash = hash(body);
+    const bodyHash = hash(body);
     body.alias = bodyHash;
 
     if (verbose) {

package/package.json

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

package/util.js

@@ -10,10 +10,7 @@ function partition(startAt, endAt, numGroups) {
   const step = Math.max(Math.floor(span / numGroups), 1);
   const adjustedStep = span % step === 0 ? step : step + 1;
 
-  return [
-    [startAt, startAt + adjustedStep - 1],
-    ...partition(startAt + adjustedStep, endAt, numGroups - 1)
-  ];
+  return [[startAt, startAt + adjustedStep - 1], ...partition(startAt + adjustedStep, endAt, numGroups - 1)];
 }
 
 // Inclusive range
@@ -50,9 +47,21 @@ function fillRange(start, end) {
   return result;
 }
 
+function chunk(array, count) {
+  if (count == null || count < 1) return [];
+  var result = [];
+  var i = 0,
+    length = array.length;
+  while (i < length) {
+    result.push(array.slice(i, (i += count)));
+  }
+  return result;
+}
+
 module.exports = {
   arrayGroup,
   partition,
   range,
-  fillRange
+  fillRange,
+  chunk
 };

package/web3.js

@@ -0,0 +1,117 @@
+const Web3 = require("web3");
+const { PROTOCOLS } = require("./const");
+const { MULTICALL } = require("./abi");
+const { chunk } = require("./util");
+const MULTICALL_CHUNK_SIZE = 400;
+
+function newWeb3ByProtocol(protocol) {
+  if (!Object.keys(PROTOCOLS).includes(protocol)) {
+    return null;
+  }
+
+  return new Web3(PROTOCOLS[protocol].endpoint);
+}
+
+function normalizeCallParams(params) {
+  if (params === undefined) {
+    return [];
+  }
+
+  if (Array.isArray(params)) {
+    return params;
+  }
+
+  return [params];
+}
+
+async function singleCall(protocol, abi, target, params) {
+  const web3 = newWeb3ByProtocol(protocol);
+
+  if (!web3) {
+    throw new Error(`unsupported protocol`);
+  }
+
+  const contract = new web3.eth.Contract([abi], target);
+  const functionSignature = web3.eth.abi.encodeFunctionSignature(abi);
+  const method = contract.methods[functionSignature];
+
+  const result = await method(...normalizeCallParams(params)).call();
+
+  return result;
+}
+
+// limiter if provided, should be an instance of Bottleneck, which is part of bottleneck package
+async function multiCall({ protocol, limiter = null, target, abi, calls }) {
+  const web3 = newWeb3ByProtocol(protocol);
+
+  if (!web3) {
+    throw new Error(`unsupported protocol`);
+  }
+
+  const multiCallProviderAddress = PROTOCOLS[protocol].multiCallProvider;
+
+  if (!multiCallProviderAddress) {
+    throw new Error("protocol doesn't support multicall yet");
+  }
+
+  if (calls.length === 0) return { callCount: 0, output: [] };
+
+  const multiCallContract = new web3.eth.Contract(MULTICALL, multiCallProviderAddress);
+
+  let maybeRateLimitedCallChunk = async (callChunk) => {
+    const txs = callChunk.map((call) => ({
+      delegateCall: false,
+      revertOnError: false,
+      gasLimit: 0,
+      target: call.target || target,
+      value: 0,
+      data: web3.eth.abi.encodeFunctionCall(abi, normalizeCallParams(call.params)),
+    }));
+
+    const response = await multiCallContract.methods.multiCall(txs).call();
+
+    return response._results.map((res, idx) => {
+      const input = {
+        target: callChunk[idx].target || target,
+        params: normalizeCallParams(callChunk[idx].params),
+      };
+
+      try {
+        const callResult = web3.eth.abi.decodeParameters(abi.outputs, res);
+
+        return {
+          input,
+          success: response._successes[idx],
+          // according to SDK doc, if there's only one, return result directly
+          output: abi.outputs.length === 1 ? callResult[0] : callResult,
+        };
+      } catch (decodeErr) {
+        console.log("decode err", abi.name, callChunk[idx].target || target, callChunk[idx].params, decodeErr.message);
+
+        return {
+          input,
+          success: false,
+          output: null,
+        };
+      }
+    });
+  };
+
+  if (limiter) {
+    maybeRateLimitedCallChunk = limiter.wrap(maybeRateLimitedCallChunk);
+  }
+
+  const callChunks = chunk(calls, MULTICALL_CHUNK_SIZE);
+
+  const responses = (
+    await Promise.all(callChunks.map(async (callChunk) => await maybeRateLimitedCallChunk(callChunk)))
+  ).flat();
+
+  return { actualCallCount: callChunks.length, output: responses };
+}
+
+module.exports = {
+  newWeb3ByProtocol,
+  singleCall,
+  multiCall,
+};