@certik/skynet 0.10.23 → 0.10.26

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.10.26
+
+- Improved support for AVAX and FTM in const.js
+- Added `beforeListen` parameter to `api` library
+
+## 0.10.25
+
+- Added support for AVAX and FTM in const.js
+
+## 0.10.24
+
+- Added type definitions
+
 ## 0.10.23
 
 - Fixed nomad API log elapse time

package/abi.d.ts

@@ -0,0 +1,20 @@
+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/ably.d.ts

@@ -0,0 +1,3 @@
+import Bottleneck from "bottleneck";
+export function publishMessage(channel: string, messageName: string, messageData: any): Promise<void>;
+export const rateLimitedPublishMessage: Bottleneck;

package/address.d.ts

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

package/api.d.ts

@@ -0,0 +1,14 @@
+import { Selector } from "./selector";
+
+export function startApiApp(params: { 
+    binaryName: string;
+    name: string;
+    selector: Selector;
+    routes: string[];
+    serve: {
+        port: string | undefined;
+        apiKey: string;
+        prefix: string | undefined;
+    };
+    beforeListen: () => void;
+}): void;

package/api.js

@@ -65,7 +65,7 @@ const apiKeyMiddleware = (key) => {
   return requireAPIKey;
 };
 
-async function startApiApp({ binaryName, name, selector = {}, routes, serve }) {
+async function startApiApp({ binaryName, name, selector = {}, routes, serve, beforeListen }) {
   const app = express();
   app.use(express.json());
 
@@ -133,6 +133,10 @@ ${getSelectorDesc(selector)}
     }
   }
 
+  if (beforeListen) {
+    await beforeListen({ app });
+  }
+
   app.listen(serve.port, () => {
     if (isProduction()) {
       inline.log(`${name} listening at https://api.certik-skynet.com${serve.prefix}`);

package/app.d.ts

@@ -0,0 +1,159 @@
+import { ERROR_LEVEL } from "./monitor";
+import { Selector } from "./selector";
+
+export type Env = {
+    [key: string]: string | null
+}
+
+export type Route = {
+    method: "POST" | "PUT" | "PATCH" | "GET" | "POST" | "DELETE" | "OPTIONS";
+    path: string;
+    handler: ({ req, res }: { req: any, res: any }) => Promise<void>;
+    protected: boolean;
+}
+
+export type Serve = {
+    prefix: string;
+    port: number;
+    apiKey: string;
+    cpu: number;
+    mem: number;
+}
+
+export type Consume = {
+    func: ({ protocol, messages, verbose }: {
+        protocol: string;
+        messages: any;
+        verbose: boolean;
+    }) => Promise<void>;
+    topic: ({ protocol }: { protocol: string }) => string;
+    maxRetry: number;
+    cpu: number;
+    mem: number;
+}
+
+export type State = {
+    type: string;
+    updateInterval: ({ protocol }: { protocol: string }) => number;
+    getMinId: () => Promise<number>;
+    getMaxId: ({ protocol }: { protocol: string }) => Promise<number>;
+}
+
+export type Produce = {
+    func: ({ protocol, from, to, verbose, send }: {
+        protocol: string;
+        from: number;
+        to: number;
+        verbose: boolean;
+        send: (items: { id: string, name: string }[]) => Promise<void>;
+    }) => Promise<void>;
+    topic: ({ protocol }) => string;
+    deadLetterTopic: ({ protocol }) => string;
+    batchSize: number;
+    maxRetry: number;
+    cpu: number;
+    mem: number;
+}
+
+export type Check = {
+    func: ({ protocol, state, verbose }: { protocol: string, state: string, verbose: boolean })
+        => ({ type: string, message: string });
+    schedule: string;
+    slackChannel: string;
+}
+
+export type Build = {
+    func: ({ protocol, from, to, verbose }: { protocol: string, from: number, to: number, verbose: boolean })
+        => void;
+    batchSize: number;
+    schedule: string;
+    cpu: number;
+    mem: number;
+}
+
+export type Restart = {
+    attempts: number | undefined;
+    mode: string | undefined;
+    interval: string | undefined;
+    delay: string | undefined
+}
+
+export type Validate = {
+    func: ({ protocol, from, to, verbose }: { protocol: string, from: number, to: number, verbose: boolean })
+        => void;
+    batchSize: number;
+    schedule: string;
+    cpu: number;
+    mem: number;
+}
+
+type BuildWithConcurrency = Build | { concurrency: number | undefined };
+
+type ValidateWithConcurrency = Validate | { concurrency: number | undefined };
+
+export const SENSITIVE_VALUE: null;
+
+export { ERROR_LEVEL };
+
+export function every(n: number | undefined): {
+    second: string
+    seconds: string,
+    minute: string,
+    minutes: string,
+    hour: string,
+    hours: string,
+    day: string,
+    days: string,
+    week: string,
+    weeks: string,
+}
+
+export function api(apiParams: {
+    name: string;
+    routes: Route[];
+    serve: Serve;
+    env: Env | undefined;
+    region: string | undefined;
+    beforeListen: () => void;
+}): () => void;
+
+export function consumer(consumerParams: {
+    name: string;
+    selector: Selector;
+    consume: Consume;
+    check: Check;
+    env: Env | undefined;
+    region: string | undefined;
+}): () => void;
+
+export function producer(producerParams: {
+    name: string;
+    selector: Selector;
+    produce: Produce;
+    check: Check;
+    state: State;
+    env: Env | undefined;
+    region: string | undefined;
+}): () => void;
+
+export function indexer(indexerParams: {
+    name: string;
+    selector: Selector;
+    state: State;
+    build: Build | { restart: Restart | undefined };
+    validate: Validate;
+    check: Check;
+    env: Env | undefined;
+    region: string | undefined;
+}): () => void;
+
+export function modeIndexer(modeIndexerParams: {
+    name: string;
+    selector: Selector;
+    state: State;
+    build: BuildWithConcurrency;
+    validate: ValidateWithConcurrency;
+    check: Check;
+    env: Env | undefined;
+    region: string | undefined;
+}): () => void;

package/app.js

@@ -600,7 +600,7 @@ function checkApiRoutesParameter(routes) {
   return errors;
 }
 
-function api({ name, routes, serve, env = {}, region = "us-east-1" }) {
+function api({ name, routes, serve, beforeListen, env = {}, region = "us-east-1" }) {
   // do not support selector for now
   const selector = {};
 
@@ -641,6 +641,7 @@ function api({ name, routes, serve, env = {}, region = "us-east-1" }) {
         selector,
         routes,
         serve,
+        beforeListen,
       });
     },
     onDeploy: () => {

package/availability.d.ts

@@ -0,0 +1,11 @@
+export function wait(time: number | undefined): Promise<void>;
+export function retry(times: number, verbose: boolean, func: Function): Promise<void>;
+export function exponentialRetry<T>(func: () => Promise<T>, { maxRetry, initialDuration, growFactor, test, verbose }:
+    {
+        maxRetry: number,
+        initialDuration: number | undefined,
+        growFactor: number | undefined,
+        test: (result: T) => boolean,
+        verbose: boolean
+    }
+): Promise<T>;

package/block.d.ts

@@ -0,0 +1,49 @@
+// See https://www.quicknode.com/docs/ethereum/eth_getBlockByNumber for a complete reference.
+
+type Transaction = {
+    blockHash: string;
+    blockNumber: string;
+    hash: string;
+    to: string;
+    from: string;
+    transactionIndex: string;
+    value: string | undefined;
+    nonce: string;
+    gas: string;
+    gasPrice: string;
+    input: string;
+    type: string;
+    chainId: string | undefined;
+    v: string;
+    r: string;
+    s: string;
+}
+
+type BlockInfo = {
+    number: string;
+    timestamp: string;
+    difficulty: string;
+    extraData: string;
+    gasLimit: string;
+    gasUsed: string;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: string;
+    stateRoot: string;
+    totalDifficulty: string;
+    transactions: Transaction[];
+    transactionsRoot: string;
+    uncles: string[];
+}
+
+export function getLatestBlockHeight(protocol: string): Promise<number>;
+export function getBlock(protocol: string, height: number): Promise<BlockInfo>;
+export function getBlockS3Path(protocol: string, height: number): string;
+export function getLatestS3BlockHeight(protocol: string): Promise<number>;
+export function getBlockFromS3(protocol: string, height: number): Promise<BlockInfo>;

package/cli.d.ts

@@ -0,0 +1,4 @@
+export function getBinaryName(): string;
+export function detectSkynetDirectory(): string;
+export function detectWorkingDirectory(): string;
+export function detectBin(): string;

package/const.d.ts

@@ -0,0 +1,40 @@
+type Protocol = {
+    nativeTokenName: string,
+    nativeTokenSymbol: string,
+    nativeTokenDecimals: number,
+    nativeTokenAddress: string,
+    nativeTokenLogo: string,
+    nativeTokenCoinGeckoId: string,
+    nativeTokenCmcId: number,
+    endpoint: string,
+    archiveEndpoint: string,
+    tokenStandard: string,
+    scanApi: {
+      endpoint: string,
+      key: string,
+    },
+    multiCallProvider: string,
+    scanUrl: string,
+}
+
+type TimeIntervals = {
+    MINUTE: number,
+    HOUR: number,
+    DAY: number,
+    WEEK: number,
+    YEAR: number,
+}
+
+export const SKYNET_API_PREFIX: string;
+export const PROTOCOLS: {
+    eth: Protocol,
+    bsc: Protocol,
+    polygon: Protocol,
+    heco: Protocol,
+    avax: Protocol,
+    ftm: Protocol,
+}
+export const TIME: {
+    BY_MS: TimeIntervals,
+    BY_S: TimeIntervals,
+}

package/const.js

@@ -1,7 +1,5 @@
 const {
-  getEtherScanApiKey,
-  getBscScanApiKey,
-  getPolygonScanApiKey,
+  getEnvironment,
   getGetBlockApiKey,
   getAlchemyApiKey,
   getNodeRealApiKey,
@@ -23,7 +21,7 @@ const PROTOCOLS = {
     tokenStandard: "ERC20",
     scanApi: {
       endpoint: "https://api.etherscan.io/api",
-      key: getEtherScanApiKey(),
+      key: getEnvironment("SKYNET_ETHER_SCAN_API_KEY"),
     },
     multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
     scanUrl: "https://etherscan.io/",
@@ -41,7 +39,7 @@ const PROTOCOLS = {
     tokenStandard: "BEP20",
     scanApi: {
       endpoint: "https://api.bscscan.com/api",
-      key: getBscScanApiKey(),
+      key: getEnvironment("SKYNET_BSC_SCAN_API_KEY"),
     },
     multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
     scanUrl: "https://bscscan.com/",
@@ -60,7 +58,7 @@ const PROTOCOLS = {
     tokenStandard: "ERC20",
     scanApi: {
       endpoint: "https://api.polygonscan.com/api",
-      key: getPolygonScanApiKey(),
+      key: getEnvironment("SKYNET_POLYGON_SCAN_API_KEY"),
     },
     multiCallProvider: "0x8eC86392e0aDB57d00fDffbA39b8870e107c0757",
     scanUrl: "https://polygonscan.com/",
@@ -74,6 +72,32 @@ const PROTOCOLS = {
     tokenStandard: "HRC20",
     multiCallProvider: "0xe7144e57d832c9005d252f415d205b4b8d78228e",
     scanUrl: "https://hecoinfo.com/"
+  },
+  avax: {
+    nativeTokenName: "Avalanche",
+    nativeTokenSymbol: "AVAX",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "avax:0x0000000000000000000000000000000000000000",
+    endpoint: `https://api.avax.network/ext/bc/C/rpc`,
+    tokenStandard: "ARC20",
+    scanApi: {
+      endpoint: "https://api.snowtrace.io",
+      key: getEnvironment("SKYNET_AVASCAN_API_KEY"),
+    },
+    scanUrl: "https://snowtrace.io/"
+  },
+  ftm: {
+    nativeTokenName: "Fantom",
+    nativeTokenSymbol: "FTM",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "ftm:0x0000000000000000000000000000000000000000",
+    endpoint: `https://rpcapi.fantom.network`,
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.ftmscan.com",
+      key: getEnvironment("SKYNET_FTMSCAN_API_KEY"),
+    },
+    scanUrl: "https://ftmscan.com/"
   }
 };
 

package/deploy.d.ts

@@ -0,0 +1,41 @@
+import { getJobName } from "./selector";
+import { Env, Selector, Check, Restart } from "./app";
+
+type Service = {
+  prefix: string;
+  port: number;
+}
+
+type CreateDeployBaseParams = {
+  binaryName: string,
+  name: string,
+  workingDirectory: string,
+  bin: string | undefined,
+  selector: Selector | undefined,
+  env: Env | undefined,
+  region: string | undefined,
+  check: Check,
+}
+
+export { getJobName };
+
+export function getNomadAddr(isProduction: boolean): Promise<string | undefined>;
+
+export function createModeDeploy(createModeDeployParams: CreateDeployBaseParams | {
+  deltaSchedule: string,
+  validateSchedule: string,
+  deltaCpu: number,
+  deltaMem: number,
+  rebuildCpu: number,
+  rebuildMem: number,
+  validateCpu: number,
+  validateMem: number,
+}): { deploy: () => void };
+
+export function createDeploy(createDeployParams: CreateDeployBaseParams | {
+  schedule: string,
+  restart: Restart | undefined,
+  cpu: number,
+  mem: number,
+  service: Service,
+}): { deploy: () => void };

package/distributed-lock.d.ts

@@ -0,0 +1 @@
+export function useLock(useLockParams: { name: string, ttl: string, verbose: boolean }): Promise<string | null>

package/dynamodb.d.ts

@@ -0,0 +1,67 @@
+import { DynamoDB } from "aws-sdk";
+
+type Keys = { [key: string]: any };
+
+type Fields = { [key: string]: any };
+
+export function getDocClient(): DynamoDB.DocumentClient;
+
+export function scanWholeTable(options: DynamoDB.DocumentClient.ScanInput): 
+Promise<{
+    Items: any[];
+    Count: number;
+    ScannedCount: number;
+}>;
+
+export function batchCreateRecords(
+    tableName: string,
+    records: any[],
+    maxWritingCapacity: number,
+    verbose: boolean | undefined
+): Promise<void>;
+
+export function createRecord(
+    tableName: string,
+    fields: Fields,
+    verbose: boolean | undefined
+): Promise<void>;
+
+export function getRecordsByKey(
+    tableName: string,
+    keys: Keys,
+    indexName: string
+): Promise<DynamoDB.DocumentClient.ItemList | null | undefined>;
+
+export function getRecordByKey(
+    tableName: string,
+    keys: Keys,
+    indexName: string
+): Promise<DynamoDB.DocumentClient.AttributeMap | null>;
+
+export function updateRecordByKey(
+    tableName: string,
+    idKey: Keys,
+    fields: Fields,
+    conditionExpressions: string | undefined,
+    verbose: boolean | undefined
+): Promise<DynamoDB.DocumentClient.AttributeMap | undefined>;
+
+export function batchDeleteRecords(
+    tableName: string,
+    keys: Keys
+): Promise<void>;
+
+export function deleteRecordsByHashKey(
+    tableName: string, 
+    indexName: string | undefined, 
+    hashKeyValue: string, 
+    verbose: boolean | undefined
+): Promise<number>;
+
+export function createTableIfNotExist(
+    tableName: string,
+    attributeDefinitions: DynamoDB.AttributeDefinitions,
+    keySchema: DynamoDB.KeySchema,
+    options: DynamoDB.DocumentClient.CreateTableInput,
+    verbose: boolean | undefined
+): Promise<void>

package/env.d.ts

@@ -0,0 +1,11 @@
+export function ensureAndGet<T>(envName: string, defaultValue: T): string | T;
+export function getEnvOrThrow(envName: string): string;
+export function getAWSAccessKeyId(): string | undefined;
+export function getAWSSecretAccessKey(): string | undefined;
+export function getAWSRegion(): string;
+export function getEnvironment(): string;
+export function getGetBlockApiKey(): string | undefined;
+export function getAlchemyApiKey(identifier: string): string | undefined;
+export function getNodeRealApiKey(identifier: string): string | undefined;
+export function isProduction(): boolean;
+export function isDev(): boolean;

package/env.js

@@ -14,18 +14,6 @@ function getEnvironment() {
   return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
 }
 
-function getEtherScanApiKey() {
-  return ensureAndGet("SKYNET_ETHER_SCAN_API_KEY");
-}
-
-function getBscScanApiKey() {
-  return ensureAndGet("SKYNET_BSC_SCAN_API_KEY");
-}
-
-function getPolygonScanApiKey() {
-  return ensureAndGet("SKYNET_POLYGON_SCAN_API_KEY");
-}
-
 function getGetBlockApiKey() {
   return ensureAndGet("SKYNET_GETBLOCK_API_KEY");
 }
@@ -81,9 +69,6 @@ module.exports = {
   getEnvironment,
   isProduction,
   isDev,
-  getEtherScanApiKey,
-  getBscScanApiKey,
-  getPolygonScanApiKey,
   getGetBlockApiKey,
   getAlchemyApiKey,
   getNodeRealApiKey,

package/indexer.d.ts

@@ -0,0 +1,30 @@
+// module.exports = {
+//     getIndexerValidatedId,
+//   };
+import { Build, State, Validate } from "./app";
+import { SelectorFlags, Selector } from "./selector";
+
+type CreateIndexerAppBaseParams = {
+    binaryName: string,
+    name: string,
+    selector: Selector | undefined,
+    build: Build,
+    maxRetry: number
+}
+
+export function createModeIndexerApp(createModeIndexerAppParams: {
+    buildBatchSize: number | undefined,
+    buildConcurrency: number | undefined,
+    validate: Validate,
+    validateBatchSize: number | undefined,
+    validateConcurrency: number | undefined,
+    state: State,
+} | CreateIndexerAppBaseParams): { run: () => void };
+
+export function createIndexerApp(createModeIndexerAppParams: CreateIndexerAppBaseParams): { run: () => void };
+
+export function getIndexerState(name: string, selectorFlags: SelectorFlags): Promise<string>;
+
+export function getIndexerLatestId(name: string, selectorFlags: SelectorFlags): Promise<number>;
+
+export function getIndexerValidatedId(name: string, selectorFlags: SelectorFlags): Promise<number>;

package/inquiry.d.ts

@@ -0,0 +1,3 @@
+import { Response } from "node-fetch";
+
+export function createAddressRecord(address: string): Promise<Response>;

package/kafka.d.ts

@@ -0,0 +1,39 @@
+import { KafkaMessage } from "kafkajs";
+import { Producer, State } from "./app";
+import { SelectorFlags, Selector } from "./selector";
+
+export function createProducerApp(createProducerAppParams: {
+    binaryName: string,
+    name: string,
+    selector: Selector | undefined,
+    producer: Producer,
+    state: State
+}): { run: () => Promise<void> };
+
+export function createConsumerApp(createConsumerAppParams: {
+    binaryName: string,
+    name: string,
+    selector: Selector | undefined,
+    consumer: Consumer
+}): { run: () => Promise<void> };
+
+export function produceMessages(
+    producerId: string, 
+    callback: (
+        send: (topic: any, messages: any) => Promise<void>
+    ) => Promise<void>
+): Promise<void>;
+
+export function consumeMessages(
+    consumerId: string, 
+    topic: string | RegExp, 
+    callback: (
+        message: KafkaMessage, 
+        stopConsumeMessages: () => Promise<void>
+    ) => Promise<void>
+): Promise<() => Promise<void>>;
+
+export function getProducerLatestId(
+    name: string,
+    selectorFlags: SelectorFlags
+): Promise<number>;

package/labelling.d.ts

@@ -0,0 +1,15 @@
+type Tag = {
+    type: string;
+    label: string;
+}
+
+export function addTagsToAddress(
+    address: string,
+    tags: Tag[],
+    verbose: boolean
+): Promise<{
+    tableName: string;
+    updateItemTags: Tag[];
+} | undefined>;
+
+export function queryAddressTags(address: string): Promise<Tag[]>;

package/log.d.ts

@@ -0,0 +1,5 @@
+export function print(o: any): string;
+export const inline: {
+    log: (...args: any[]) => void,
+    error: (...args: any[]) => void
+};

package/metric.d.ts

@@ -0,0 +1,10 @@
+export function getMetricAt(
+    tableName: string,
+    name: string,
+    timestamp: number
+): Promise<any>;
+export function getMetricPreviousValue(
+    tableName: string,
+    name: string,
+    timestamp: number
+): Promise<any>;

package/monitor.d.ts

@@ -0,0 +1,24 @@
+import { Check } from "./app";
+import { SelectorFlags, Selector } from "./selector";
+
+export const ERROR_LEVEL: {
+    INFO: string,
+    CRITICAL: string,
+    WARNING: string
+};
+
+export const LEVEL_EMOJI: {
+    Info: string,
+    Critical: string,
+    Warning: string
+};
+
+export function createMonitor(createMonitorParams: {
+    binaryName: string,
+    name: string,
+    getState: ((name: string, selectorFlags: SelectorFlags) => Promise<void>) | undefined,
+    mode: boolean | undefined,
+    selector: Selector,
+    check: Check,
+    maxRetry: number | undefined
+}): { monitor: () => void };

package/opsgenie.d.ts

@@ -0,0 +1,7 @@
+export function postGenieMessage(
+    body: any | {
+        alias: string, 
+        message: string
+    }, 
+    verbose: boolean
+): Promise<{ result: string }>;

package/package.json

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

package/price.d.ts

@@ -0,0 +1,8 @@
+type PricePreviousRecord = {
+    address: string;
+    price: number;
+    timestamp: number;
+}
+
+export function getPriceClosestTo(tableName: string, address: string, timestamp: number): Promise<number>;
+export function getPricePreviousRecord(tableName: string, address: string, timestamp: number): Promise<PricePreviousRecord | null>;

package/primitive.d.ts

@@ -0,0 +1,29 @@
+import { DynamoDB } from "aws-sdk";
+
+type Issue = {
+    code: string;
+    link: string;
+    reduction: number;
+    title: string;
+}
+
+export function getOverrides(
+    docClient: DynamoDB.DocumentClient, 
+    projectId: string, 
+    address: string, 
+    log: (...data: any[]) => void, 
+    primitive: string
+): Promise<string[] | null>;
+
+export function overrideScoreAndIssues(
+    docClient: DynamoDB.DocumentClient,
+    projectId: string,
+    address: string,
+    score: number,
+    issues: Issue[],
+    log: (...data: any[]) => void,
+    primitive: string
+): Promise<{
+    score: number;
+    issues: Issue[];
+}>

package/proxy.d.ts

@@ -0,0 +1,11 @@
+import { RequestInit, Response } from "node-fetch";
+
+type Options = {
+    verbose: boolean;
+    timeout: number;
+    headers: {
+        [header: string]: string;
+    }
+} | RequestInit;
+
+export default function proxyFetch(url: string, options: Partial<Options> | undefined): Promise<Response>;

package/rateLimit.d.ts

@@ -0,0 +1 @@
+export function isRateLimited(name: string, unitTime: number, maxAccess: number): Promise<boolean>;

package/s3.d.ts

@@ -0,0 +1,16 @@
+import { S3 } from "aws-sdk";
+
+type WriteOptions = {
+    verbose: boolean;
+    acl: string;
+    skipIfExists: boolean;
+}
+
+export function getS3(): S3;
+export function readFile(bucketName: string, key: string, verbose: boolean | undefined): Promise<string | null>;
+export function hasFile(bucketName: string, key: string): Promise<boolean>;
+export function writeFile(bucketName: string, key: string, body: any, options: Partial<WriteOptions> | undefined): Promise<void>;
+export function deleteFile(bucketName: string, key: string, verbose: boolean | undefined): Promise<void>;
+export function listKeys(bucketname: string, prefix: string, continuationToken: string | undefined): Promise<{
+    keys: (string | undefined)[];
+} | null>;

package/scan.d.ts

@@ -0,0 +1,47 @@
+type Transaction = {
+    blockNumber: string,
+    timeStamp: string,
+    hash: string,
+    nonce: string,
+    blockHash: string,
+    transactionIndex: string,
+    from: string,
+    to: string,
+    value: string | undefined,
+    gas: string,
+    gasPrice: string,
+    isError: string,
+    txreceipt_status: string,
+    input: string,
+    contractAddress: string,
+    cumulativeGasUsed: string,
+    gasUsed: string,
+    confirmations: string,
+    methodId: string,
+    functionName: string
+}
+
+export function streamTxs(
+    address: string, 
+    since: number | undefined, 
+    to: number | undefined,
+    callback: (tx: Transaction) => void, 
+    verbose: boolean
+): Promise<void>;
+
+export function fetchTxs(
+    protocol: string, 
+    addr: string, 
+    since: number | undefined, 
+    to: number | undefined, 
+    offset: number | undefined,
+): Promise<Transaction[] | null>;
+
+export function fetchTxsWithRetry(
+    protocol: string, 
+    addr: string, 
+    since: number | undefined, 
+    to: number | undefined, 
+    offset: number | undefined,
+    verbose: boolean
+): Promise<Transaction[] | null>

package/selector.d.ts

@@ -0,0 +1,19 @@
+export type SelectorFlags = {
+    [flag: string]: string;
+}
+
+export type Selector = {
+    [key: string]: {
+        type: string;
+        description: string | undefined;
+        desc: string | undefined;
+        alias: string | undefined,
+        isRequired: boolean | undefined,
+        default: string | boolean | undefined;
+    }
+}
+
+export function getJobName(name: string, selectorFlags: SelectorFlags, mode: string | undefined): string;
+export function getSelectorDesc(selector: Selector): string;
+export function getSelectorFlags(selector: Selector): SelectorFlags;
+export function toSelectorString(selectorFlags: SelectorFlags, delim: string | undefined): string;

package/slack.d.ts

@@ -0,0 +1,5 @@
+import { WebClient } from "@slack/web-api";
+
+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>;

package/snowflake.d.ts

@@ -0,0 +1,4 @@
+import { ConnectionOptions, Connection, Binds } from "snowflake-sdk";
+
+export function getConnection(options: ConnectionOptions): Promise<Connection>;
+export function executeSql(options: ConnectionOptions, sql: string, binds: Binds): Promise<any[]>;

package/sqs.d.ts

@@ -0,0 +1,3 @@
+import { SQS } from "aws-sdk";
+
+export function getSQS(): SQS;

package/token.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from "bignumber.js";
+
+export function getTokenPriceAt(tokenAddress: string, timestamp: number, useCache: boolean | undefined): Promise<number>;
+export function toNativeDecimal(bigNumber: BigNumber, decimals: number): Promise<BigNumber>;
+export function toHumanDecimal(bigNumber: BigNumber, decimals: number): Promise<BigNumber>;

package/transaction.d.ts

@@ -0,0 +1,30 @@
+type Log = {
+    address: string,
+    topics: string[],
+    data: string,
+    blockNumber: string,
+    transactionHash: string,
+    transactionIndex: string,
+    blockHash: string,
+    logIndex: string,
+    removed: boolean
+}
+
+type TransactionReceipt = {
+    blockHash: string,
+    blockNumber: string,
+    contractAddress: string | null,
+    cumulativeGasUsed: string,
+    effectiveGasPrice: string,
+    from: string,
+    gasUsed: string,
+    logs: Log[],
+    logsBloom: string,
+    status: string,
+    to: string,
+    transactionHash: string,
+    transactionIndex: string,
+    type: string
+}
+
+export function getTxReceipt(protocol: string, txHash: string, verbose: boolean): Promise<TransactionReceipt | null>;

package/util.d.ts

@@ -0,0 +1,5 @@
+export function arrayGroup<T>(array:T[], groupSize: number): T[][];
+export function partition(startAt: number, endAt: number, numGroups: number): [number, number][];
+export function range(startAt: number, endAt: number, step: number): [number, number][];
+export function fillRange(startAt: number, endAt: number): number[];
+export function chunk<T>(array: T[], count: number): T[][];

package/web3.d.ts

@@ -0,0 +1,23 @@
+import Bottleneck from "bottleneck";
+import Web3 from "web3";
+import { ABI } from "./abi";
+
+type Call = {
+    params: any | any[],
+    functionName: string | undefined,
+    target: string | undefined
+} | any[];
+
+export function newWeb3ByProtocol(protocol: string): Web3
+export function singleCall(protocol: string, abi: ABI, target: string, params: any[]): Promise<any>;
+export function multiCall(multiCallParams: {
+    protocol: string;
+    limiter: Bottleneck | undefined;
+    target: string;
+    abi: ABI;
+    calls: Call[];
+}): Promise<{
+    callCount: number;
+    actualCallCount: number | undefined;
+    output: any[];
+}>;