@certik/skynet 0.10.7 → 0.10.10

package/snowflake.js

@@ -1,36 +1,36 @@
-const snowflake = require("snowflake-sdk");
-const { promisify } = require("util");
-const { ensureAndGet } = require("./env");
-
-async function getConnection(options) {
-  const connection = snowflake.createConnection({
-    account: ensureAndGet("SKYNET_SNOWFLAKE_ACCOUNT"),
-    username: ensureAndGet("SKYNET_SNOWFLAKE_USERNAME"),
-    password: ensureAndGet("SKYNET_SNOWFLAKE_PASSWORD"),
-    ...options,
-  });
-  return await promisify(connection.connect).bind(connection)();
-}
-
-async function executeSql(options, sql, binds) {
-  const connection = await getConnection(options);
-  return await new Promise((resolve, reject) => {
-    connection.execute({
-      sqlText: sql,
-      binds: binds,
-      complete: (err, statement, rows) => {
-        // console.log(statement.getSqlText());
-        if (err) {
-          reject(err);
-        } else {
-          resolve(rows);
-        }
-      },
-    });
-  });
-}
-
-module.exports = {
-  getConnection,
-  executeSql,
-};
+const snowflake = require("snowflake-sdk");
+const { promisify } = require("util");
+const { ensureAndGet } = require("./env");
+
+async function getConnection(options) {
+  const connection = snowflake.createConnection({
+    account: ensureAndGet("SKYNET_SNOWFLAKE_ACCOUNT"),
+    username: ensureAndGet("SKYNET_SNOWFLAKE_USERNAME"),
+    password: ensureAndGet("SKYNET_SNOWFLAKE_PASSWORD"),
+    ...options,
+  });
+  return await promisify(connection.connect).bind(connection)();
+}
+
+async function executeSql(options, sql, binds) {
+  const connection = await getConnection(options);
+  return await new Promise((resolve, reject) => {
+    connection.execute({
+      sqlText: sql,
+      binds: binds,
+      complete: (err, statement, rows) => {
+        // console.log(statement.getSqlText());
+        if (err) {
+          reject(err);
+        } else {
+          resolve(rows);
+        }
+      },
+    });
+  });
+}
+
+module.exports = {
+  getConnection,
+  executeSql,
+};

package/sqs.js

@@ -1,12 +1,12 @@
-const { SQS } = require("aws-sdk");
-const { getAWSAccessKeyId, getAWSSecretAccessKey, getAWSRegion } = require("./env");
-
-function getSQS() {
-  return new SQS({
-    accessKeyId: getAWSAccessKeyId(),
-    secretAccessKey: getAWSSecretAccessKey(),
-    region: getAWSRegion(),
-  });
-}
-
-module.exports = { getSQS };
+const { SQS } = require("aws-sdk");
+const { getAWSAccessKeyId, getAWSSecretAccessKey, getAWSRegion } = require("./env");
+
+function getSQS() {
+  return new SQS({
+    accessKeyId: getAWSAccessKeyId(),
+    secretAccessKey: getAWSSecretAccessKey(),
+    region: getAWSRegion(),
+  });
+}
+
+module.exports = { getSQS };

package/token.js

@@ -1,46 +1,46 @@
-const { getEnvironment } = require("./env");
-const { getPriceClosestTo } = require("./price");
-const BigNumber = require("bignumber.js");
-
-const TOKEN_PRICE_TABLE_NAME = `skynet-${getEnvironment()}-token-prices`;
-const TOKEN_PRICE_CACHE = {};
-
-async function getTokenPriceAt(tokenAddress, timestamp, useCache = true) {
-  // to avoid huge amount of dynamodb query
-  // "ceil" timestamp to the closest proximate timestamp
-  // 100_000 seconds ~= a bit more than 1 day 86_400 seconds
-  // and use cache
-  const proximateTimestamp = timestamp + 100_000 - (timestamp % 100_000);
-
-  if (useCache && TOKEN_PRICE_CACHE[tokenAddress] && TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp]) {
-    return TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp];
-  }
-
-  const price = await getPriceClosestTo(TOKEN_PRICE_TABLE_NAME, tokenAddress, proximateTimestamp);
-
-  if (useCache) {
-    if (!TOKEN_PRICE_CACHE[tokenAddress]) {
-      TOKEN_PRICE_CACHE[tokenAddress] = {};
-    }
-
-    TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp] = price;
-  }
-
-  return price;
-}
-
-function toNativeDecimal(bigNumber, decimals) {
-  const dividend = new BigNumber(10).exponentiatedBy(new BigNumber(decimals));
-  return new BigNumber(bigNumber).multipliedBy(dividend);
-}
-
-function toHumanDecimal(bigNumber, decimals) {
-  const dividend = new BigNumber(10).exponentiatedBy(new BigNumber(decimals));
-  return new BigNumber(bigNumber).dividedBy(dividend);
-}
-
-module.exports = {
-  getTokenPriceAt,
-  toNativeDecimal,
-  toHumanDecimal,
-};
+const { getEnvironment } = require("./env");
+const { getPriceClosestTo } = require("./price");
+const BigNumber = require("bignumber.js");
+
+const TOKEN_PRICE_TABLE_NAME = `skynet-${getEnvironment()}-token-prices`;
+const TOKEN_PRICE_CACHE = {};
+
+async function getTokenPriceAt(tokenAddress, timestamp, useCache = true) {
+  // to avoid huge amount of dynamodb query
+  // "ceil" timestamp to the closest proximate timestamp
+  // 100_000 seconds ~= a bit more than 1 day 86_400 seconds
+  // and use cache
+  const proximateTimestamp = timestamp + 100_000 - (timestamp % 100_000);
+
+  if (useCache && TOKEN_PRICE_CACHE[tokenAddress] && TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp]) {
+    return TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp];
+  }
+
+  const price = await getPriceClosestTo(TOKEN_PRICE_TABLE_NAME, tokenAddress, proximateTimestamp);
+
+  if (useCache) {
+    if (!TOKEN_PRICE_CACHE[tokenAddress]) {
+      TOKEN_PRICE_CACHE[tokenAddress] = {};
+    }
+
+    TOKEN_PRICE_CACHE[tokenAddress][proximateTimestamp] = price;
+  }
+
+  return price;
+}
+
+function toNativeDecimal(bigNumber, decimals) {
+  const dividend = new BigNumber(10).exponentiatedBy(new BigNumber(decimals));
+  return new BigNumber(bigNumber).multipliedBy(dividend);
+}
+
+function toHumanDecimal(bigNumber, decimals) {
+  const dividend = new BigNumber(10).exponentiatedBy(new BigNumber(decimals));
+  return new BigNumber(bigNumber).dividedBy(dividend);
+}
+
+module.exports = {
+  getTokenPriceAt,
+  toNativeDecimal,
+  toHumanDecimal,
+};

package/transaction.js

@@ -1,41 +1,41 @@
-const fetch = require("node-fetch");
-const { PROTOCOLS } = require("./const");
-const { exponentialRetry } = require("./availability");
-
-async function getTxReceipt(protocol, txHash, verbose = false) {
-  let { endpoint } = PROTOCOLS[protocol];
-
-  const body = {
-    jsonrpc: "2.0",
-    method: "eth_getTransactionReceipt",
-    params: [txHash],
-    id: 1
-  };
-
-  const response = await exponentialRetry(
-    () => {
-      return fetch(endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
-    },
-    {
-      maxRetry: 6,
-      test: r => r.ok,
-      verbose
-    }
-  );
-
-  if (!response.ok) {
-    return null;
-  }
-
-  const { result } = await response.json();
-
-  return result;
-}
-
-module.exports = {
-  getTxReceipt
-};
+const fetch = require("node-fetch");
+const { PROTOCOLS } = require("./const");
+const { exponentialRetry } = require("./availability");
+
+async function getTxReceipt(protocol, txHash, verbose = false) {
+  let { endpoint } = PROTOCOLS[protocol];
+
+  const body = {
+    jsonrpc: "2.0",
+    method: "eth_getTransactionReceipt",
+    params: [txHash],
+    id: 1
+  };
+
+  const response = await exponentialRetry(
+    () => {
+      return fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    },
+    {
+      maxRetry: 6,
+      test: r => r.ok,
+      verbose
+    }
+  );
+
+  if (!response.ok) {
+    return null;
+  }
+
+  const { result } = await response.json();
+
+  return result;
+}
+
+module.exports = {
+  getTxReceipt
+};

package/util.js

@@ -1,67 +1,67 @@
-// Inclusive endAt
-function partition(startAt, endAt, numGroups) {
-  if (numGroups === 0 || startAt > endAt) {
-    return [];
-  } else if (startAt === endAt) {
-    return [[startAt, endAt]];
-  }
-
-  const span = endAt - startAt + 1;
-  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)];
-}
-
-// Inclusive range
-function range(startAt, endAt, step) {
-  let arr = [];
-
-  for (let i = startAt; i <= endAt; i += step) {
-    arr.push([i, Math.min(endAt, i + step - 1)]);
-  }
-
-  return arr;
-}
-
-function arrayGroup(array, groupSize) {
-  const groups = [];
-
-  for (let i = 0; i < array.length; i += groupSize) {
-    groups.push(array.slice(i, i + groupSize));
-  }
-
-  return groups;
-}
-
-// return an array with numbers of given inclusive range
-// given 1, 5
-// return [1, 2, 3, 4, 5]
-function fillRange(start, end) {
-  let result = [];
-
-  for (let i = start; i <= end; i++) {
-    result.push(i);
-  }
-
-  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,
-  chunk
-};
+// Inclusive endAt
+function partition(startAt, endAt, numGroups) {
+  if (numGroups === 0 || startAt > endAt) {
+    return [];
+  } else if (startAt === endAt) {
+    return [[startAt, endAt]];
+  }
+
+  const span = endAt - startAt + 1;
+  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)];
+}
+
+// Inclusive range
+function range(startAt, endAt, step) {
+  let arr = [];
+
+  for (let i = startAt; i <= endAt; i += step) {
+    arr.push([i, Math.min(endAt, i + step - 1)]);
+  }
+
+  return arr;
+}
+
+function arrayGroup(array, groupSize) {
+  const groups = [];
+
+  for (let i = 0; i < array.length; i += groupSize) {
+    groups.push(array.slice(i, i + groupSize));
+  }
+
+  return groups;
+}
+
+// return an array with numbers of given inclusive range
+// given 1, 5
+// return [1, 2, 3, 4, 5]
+function fillRange(start, end) {
+  let result = [];
+
+  for (let i = start; i <= end; i++) {
+    result.push(i);
+  }
+
+  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,
+  chunk
+};

package/web3.js

@@ -1,117 +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,
-};
+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,
+};