@certik/skynet 0.18.8 → 0.19.0

package/{opsgenie.js → opsgenie.ts}

@@ -1,17 +1,40 @@
 import md5 from "md5";
 
-function getGenieKey(key) {
-  return key || process.env.SKYNET_OPSGENIE_API_KEY;
+type OpsgenieResponse = {
+  data: {
+    success: boolean;
+    action: string;
+    processedAt: string;
+    integrationId: string;
+    isSuccess: boolean;
+    status: string;
+    alertId: string;
+    alias: string;
+  };
+  took: number;
+  requestId: string;
+};
+
+function getGenieKey(key?: string) {
+  return key || process.env["SKYNET_OPSGENIE_API_KEY"];
 }
 
 function getGenieEndPoint() {
-  return process.env.SKYNET_OPSGENIE_END_POINT || "https://api.opsgenie.com/v2/alerts";
+  return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
 }
 
-export async function postGenieMessage(body, apiKey, verbose) {
+export async function postGenieMessage(
+  body: {
+    alias?: string;
+    message: string;
+    description?: string;
+  },
+  apiKey?: string,
+  verbose?: boolean,
+) {
   try {
     const genieKey = apiKey || getGenieKey();
-    const genieEndPoint = getGenieEndPoint(genieKey);
+    const genieEndPoint = getGenieEndPoint();
 
     // Prevents duplicate alerts (See Opsgenie doc about alias)
     if (!body.alias) {
@@ -32,7 +55,7 @@ export async function postGenieMessage(body, apiKey, verbose) {
       body: JSON.stringify(body),
     });
 
-    const result = await response.json();
+    const result: OpsgenieResponse = await response.json();
     if (verbose) {
       console.log(`Result of API call to Opsgenie... ${result}`);
     }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@certik/skynet",
-  "version": "0.18.8",
+  "version": "0.19.0",
   "description": "Skynet Shared JS library",
   "type": "module",
-  "main": "index.js",
+  "main": "index.ts",
   "author": "CertiK Engineering",
   "scripts": {
-    "lint": "eslint *.js test",
-    "test": "doppler run -- ava --timeout=1m",
-    "format": "prettier --write '*.js' '**/*.js' '*.d.ts' '**/*.d.ts'",
+    "lint": "eslint '*.ts' test/*.ts",
+    "test": "doppler run -- bun test",
+    "format": "prettier --write '*.ts' '**/*.ts'",
     "pub": "npm publish --access public"
   },
   "engines": {
@@ -22,26 +22,33 @@
     "@databricks/sql": "^1.9.0",
     "@elastic/elasticsearch": "^8.14.0",
     "@slack/web-api": "^6.11.0",
-    "bottleneck": "^2.19.5",
     "chalk": "^5.3.0",
     "execa": "^9.3.0",
-    "express": "^4.19.2",
+    "express": "^4.21.2",
     "md5": "^2.3.0",
     "meow": "^13.2.0",
     "snowflake-sdk": "^1.11.0",
+    "type-fest": "^4.30.2",
     "web3": "^4.11.0",
     "which": "^4.0.0"
   },
   "devDependencies": {
-    "ava": "^6.1.3",
-    "eslint": "^8.45.0",
+    "@eslint/js": "^9.17.0",
+    "@types/bun": "^1.1.15",
+    "@types/express": "^5.0.0",
+    "@types/md5": "^2.3.5",
+    "@types/which": "^3.0.4",
+    "eslint": "^9.17.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-md": "^1.0.19",
+    "eslint-plugin-prettier": "^5.0.0",
     "prettier": "^3.3.3",
-    "sinon": "^18.0.0"
+    "sinon": "^18.0.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.1"
   },
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/{s3.js → s3.ts}

@@ -7,9 +7,11 @@ import {
   ListObjectsV2Command,
   NotFound,
   NoSuchKey,
+  ObjectCannedACL,
 } from "@aws-sdk/client-s3";
+import type { PutObjectCommandInput, ListObjectsV2CommandInput, ListObjectsV2CommandOutput } from "@aws-sdk/client-s3";
 
-let _s3Client;
+let _s3Client: S3Client;
 
 function getS3(forceNew = false) {
   if (!_s3Client || forceNew) {
@@ -18,14 +20,14 @@ function getS3(forceNew = false) {
   return _s3Client;
 }
 
-async function readFile(bucketName, key, verbose = false) {
+async function readFile(bucketName: string, key: string, verbose = false) {
   const s3 = getS3();
 
   const params = { Bucket: bucketName, Key: key };
 
   try {
     const result = await s3.send(new GetObjectCommand(params));
-    return result.Body.transformToString();
+    return result.Body?.transformToString();
   } catch (error) {
     if (error instanceof NoSuchKey) {
       if (verbose) {
@@ -39,7 +41,7 @@ async function readFile(bucketName, key, verbose = false) {
   }
 }
 
-async function hasFile(bucketName, key) {
+async function hasFile(bucketName: string, key: string) {
   const s3 = getS3();
 
   try {
@@ -55,7 +57,7 @@ async function hasFile(bucketName, key) {
   }
 }
 
-async function getFileSize(bucketName, key) {
+async function getFileSize(bucketName: string, key: string) {
   const s3 = getS3();
 
   const result = await s3.send(
@@ -67,7 +69,17 @@ async function getFileSize(bucketName, key) {
   return result.ContentLength;
 }
 
-async function writeFile(bucketName, key, body, options = {}) {
+async function writeFile(
+  bucketName: string,
+  key: string,
+  body: string,
+  options: {
+    verbose?: boolean;
+    skipIfExists?: boolean;
+    acl?: ObjectCannedACL;
+    contentType?: string;
+  } = {},
+) {
   const s3 = getS3();
 
   if (options.skipIfExists) {
@@ -78,7 +90,7 @@ async function writeFile(bucketName, key, body, options = {}) {
 
   const verbose = options.verbose || false;
 
-  const params = { Bucket: bucketName, Key: key, Body: body };
+  const params: PutObjectCommandInput = { Bucket: bucketName, Key: key, Body: body };
 
   if (options.acl) {
     params.ACL = options.acl;
@@ -95,7 +107,7 @@ async function writeFile(bucketName, key, body, options = {}) {
   await s3.send(new PutObjectCommand(params));
 }
 
-async function deleteFile(bucketName, key, verbose = false) {
+async function deleteFile(bucketName: string, key: string, verbose = false) {
   const s3 = getS3();
 
   const params = { Bucket: bucketName, Key: key };
@@ -115,20 +127,20 @@ async function deleteFile(bucketName, key, verbose = false) {
   }
 }
 
-async function listKeys(bucketname, prefix, continuationToken) {
+async function listKeys(bucketName: string, prefix?: string, continuationToken?: string) {
   const s3 = getS3();
 
-  const params = {
-    Bucket: bucketname,
+  const params: ListObjectsV2CommandInput = {
+    Bucket: bucketName,
     Prefix: prefix,
     ContinuationToken: continuationToken,
   };
 
-  let data = null;
+  let data: ListObjectsV2CommandOutput;
   try {
     data = await s3.send(new ListObjectsV2Command(params));
   } catch (err) {
-    if (err.statusCode && err.statusCode === 400) {
+    if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
       return null;
     }
 
@@ -139,12 +151,10 @@ async function listKeys(bucketname, prefix, continuationToken) {
     return { keys: [] };
   }
 
-  let res = { keys: data.Contents.map(({ Key }) => Key) };
-  if (data.IsTruncated) {
-    res.continuationToken = data.NextContinuationToken;
-  }
-
-  return res;
+  return {
+    keys: data.Contents.map(({ Key }) => Key),
+    continuationToken: data.IsTruncated ? data.NextContinuationToken : undefined,
+  };
 }
 
 export { getS3, hasFile, readFile, writeFile, deleteFile, getFileSize, listKeys };

package/search.ts

@@ -0,0 +1,37 @@
+import { isProduction } from "./env.ts";
+import { inline } from "./log.ts";
+import { Client } from "@elastic/elasticsearch";
+import osModule from "os";
+
+type ElasticSearchRecord = {
+  [key: string]: unknown;
+};
+
+export async function sendToSearch(indexPrefix: string, record: ElasticSearchRecord, throws = false) {
+  if (!process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] || !process.env["SKYNET_ELASTICSEARCH_API_KEY"]) {
+    throw new Error("SKYNET_ELASTICSEARCH_CLOUD_ID or SKYNET_ELASTICSEARCH_API_KEY is not set");
+  }
+
+  const client = new Client({
+    cloud: { id: process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] },
+    auth: { apiKey: process.env["SKYNET_ELASTICSEARCH_API_KEY"] },
+  });
+
+  const now = new Date();
+  const indexName = [indexPrefix, isProduction() ? "prod" : "dev", now.toISOString().slice(0, 7)].join("-");
+
+  // best as possible delivery
+  // by default not throw
+  try {
+    await client.index({
+      index: indexName,
+      document: { instance: osModule.hostname(), timestamp: now, record },
+    });
+  } catch (err) {
+    inline.error(err);
+
+    if (throws) {
+      throw err;
+    }
+  }
+}

package/selector.ts

@@ -0,0 +1,72 @@
+import type { Flag, Result } from "meow";
+
+type StringFlag = Flag<"string", string> | Flag<"string", string[], true>;
+type BooleanFlag = Flag<"boolean", boolean> | Flag<"boolean", boolean[], true>;
+type NumberFlag = Flag<"number", number> | Flag<"number", number[], true>;
+type AnyFlag = StringFlag | BooleanFlag | NumberFlag;
+
+export type Selector = Record<
+  string,
+  AnyFlag & { desc?: string; description?: string; optional?: boolean; aliases?: string[] }
+>;
+export type SelectorFlags<TSelector extends Selector> = Result<TSelector>["flags"];
+
+function getSelectorDesc(selector: Selector) {
+  return Object.keys(selector)
+    .map((name) => {
+      return `          --${name.padEnd(14)}${selector[name].desc || selector[name].description || ""}`;
+    })
+    .join("\n");
+}
+
+// check https://github.com/sindresorhus/meow for selector config options
+function getSelectorFlags<TSelector extends Selector>(selector: Selector): TSelector {
+  return Object.keys(selector).reduce((acc, name) => {
+    const flag = {
+      type: selector[name].type || "string",
+      ...selector[name],
+    };
+
+    // by default to be required
+    if (!selector[name].optional && selector[name].isRequired !== false) {
+      flag.isRequired = true;
+    }
+
+    return { ...acc, [name]: flag };
+  }, {} as TSelector);
+}
+
+function toSelectorString<TSelector extends Selector>(selectorFlags: SelectorFlags<TSelector>, delim = ",") {
+  return Object.keys(selectorFlags)
+    .sort() // deterministic
+    .map((flag) => {
+      return `${flag}=${selectorFlags[flag]}`;
+    })
+    .join(delim);
+}
+
+function normalizeSelectorValue(v: string) {
+  return v.replace(/[^A-Za-z0-9]+/g, "-");
+}
+
+function getJobName<TSelector extends Selector>(name: string, selectorFlags: SelectorFlags<TSelector>, mode?: string) {
+  const selectorNamePart = Object.keys(selectorFlags)
+    .sort()
+    .map((name) => selectorFlags[name])
+    .join("-");
+
+  let jobName = name;
+
+  if (mode) {
+    jobName += `-${mode}`;
+  }
+
+  if (selectorNamePart.length > 0) {
+    // handle special case
+    jobName += `-${normalizeSelectorValue(selectorNamePart)}`;
+  }
+
+  return jobName;
+}
+
+export { getJobName, getSelectorDesc, getSelectorFlags, toSelectorString };

package/{slack.js → slack.ts}

@@ -1,23 +1,30 @@
 import { WebClient } from "@slack/web-api";
+import type { ChatPostMessageArguments } from "@slack/web-api";
 
-function getClient(token) {
-  const client = new WebClient(token);
-
-  return client;
+function getClient(token?: string) {
+  return new WebClient(token);
 }
 
 // you can identify conversation ID at the bottom of the channel settings page
-async function postMessageToConversation({ conversationId, message, token, verbose }) {
+async function postMessageToConversation({
+  conversationId,
+  message,
+  token,
+  verbose,
+}: {
+  conversationId: string;
+  message: string | Partial<ChatPostMessageArguments>;
+  token?: string;
+  verbose?: boolean;
+}) {
+  if (!token) {
+    throw new Error("missing slack token");
+  }
+
   try {
     const client = getClient(token);
 
-    let post = {};
-
-    if (typeof message === "string") {
-      post.text = message;
-    } else {
-      post = message;
-    }
+    const post = typeof message === "string" ? { text: message } : message;
 
     if (verbose) {
       console.log(`posting to slack conversation ${conversationId}:`, JSON.stringify(post, null, 2));

package/snowflake.ts

@@ -0,0 +1,51 @@
+import snowflake from "snowflake-sdk";
+import type { ConnectionOptions, Connection, Binds } from "snowflake-sdk";
+import { ensureAndGet } from "./env.js";
+
+async function getConnection(options: Partial<ConnectionOptions>) {
+  const account = ensureAndGet("SKYNET_SNOWFLAKE_ACCOUNT");
+  const username = ensureAndGet("SKYNET_SNOWFLAKE_USERNAME");
+  const password = ensureAndGet("SKYNET_SNOWFLAKE_PASSWORD");
+
+  if (!account || !username || !password) {
+    throw new Error("missing snowflake credentials");
+  }
+
+  const connection = snowflake.createConnection({
+    account,
+    username,
+    password,
+    ...options,
+  });
+
+  return new Promise<Connection>((resolve, reject) => {
+    connection.connect((err, conn) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(conn);
+      }
+    });
+  });
+}
+
+async function executeSql<T>(options: ConnectionOptions, sql: string, binds?: Binds) {
+  const connection = await getConnection(options);
+
+  return await new Promise<T[] | undefined>((resolve, reject) => {
+    connection.execute({
+      sqlText: sql,
+      binds: binds,
+      complete: (err, statement, rows) => {
+        // console.log(statement.getSqlText());
+        if (err) {
+          reject(err);
+        } else {
+          resolve(rows);
+        }
+      },
+    });
+  });
+}
+
+export { getConnection, executeSql };

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noPropertyAccessFromIndexSignature": true,
+  },
+}

package/util.ts

@@ -0,0 +1,35 @@
+// Inclusive range
+function range(startAt: number, endAt: number, step: number) {
+  const arr: [number, number][] = [];
+
+  for (let i = startAt; i <= endAt; i += step) {
+    arr.push([i, Math.min(endAt, i + step - 1)]);
+  }
+
+  return arr;
+}
+
+function arrayGroup<T>(array: T[], groupSize: number) {
+  const groups: T[][] = [];
+
+  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: number, end: number) {
+  const result: number[] = [];
+
+  for (let i = start; i <= end; i++) {
+    result.push(i);
+  }
+
+  return result;
+}
+
+export { arrayGroup, range, fillRange };

package/web3.ts

@@ -0,0 +1,41 @@
+import { Web3 } from "web3";
+import type { AbiFunctionFragment } from "web3";
+import { PROTOCOLS } from "./const.ts";
+
+function newWeb3ByProtocol(protocol: string) {
+  if (!Object.keys(PROTOCOLS).includes(protocol)) {
+    return null;
+  }
+
+  return new Web3(PROTOCOLS[protocol].endpoint);
+}
+
+function normalizeCallParams<T>(params?: T) {
+  if (params === undefined) {
+    return [] as T[];
+  }
+
+  if (Array.isArray(params)) {
+    return params as T[];
+  }
+
+  return [params];
+}
+
+async function singleCall<TData, TParams>(protocol: string, abi: AbiFunctionFragment, target: string, params: TParams) {
+  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<TData>();
+
+  return result;
+}
+
+export { singleCall };

package/.eslintignore

@@ -1 +0,0 @@
-*.d.ts

package/.eslintrc.json

@@ -1,20 +0,0 @@
-{
-  "extends": ["eslint:recommended", "plugin:import/recommended",  "plugin:md/prettier"],
-  "parserOptions": {
-    "ecmaVersion": 2023
-  },
-  "env": {
-    "node": true,
-    "browser": false,
-    "es2023": true
-  },
-  "settings": {
-    "import/core-modules": ["ava", "meow"],
-    "import/resolver": {
-      "node": {
-        "extensions": [".js", ".jsx", ".ts", ".tsx"]
-      }
-    }
-  },
-  "rules": {}
-}

package/abi.d.ts

@@ -1,20 +0,0 @@
-type ContractIO = {
-  name: string;
-  type: string;
-  internalType: string | undefined;
-  components: ContractIO[];
-};
-
-type ABI = {
-  constant: boolean;
-  inputs: ContractIO[];
-  name: string;
-  outputs: ContractIO[];
-  payable: boolean;
-  stateMutability: string;
-  type: string;
-}[];
-
-export const ERC20: ABI;
-export const MULTICALL: ABI;
-export const BEP20: ABI;

package/address.d.ts

@@ -1,2 +0,0 @@
-export function parseAddress(address: string): [string, string];
-export function composeAddress(protocol: string, addr: string): string;

package/api.d.ts

@@ -1,12 +0,0 @@
-import { Selector } from "./selector";
-import { Route, Serve } from "./app";
-import express from "express";
-
-export function startApiApp(params: {
-  binaryName: string;
-  name: string;
-  selector?: Selector;
-  routes: Route[];
-  serve: Serve;
-  beforeListen: (args: { app: ReturnType<typeof express> }) => void;
-}): void;