@certik/skynet 0.11.4 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.13.0
+
+- BREAKING: removed ably library (@certik/skynet/ably)
+- BREAKING: removed metric library (@certik/skynet/metric)
+- BREAKING: removed scan library (@certik/skynet/scan)
+- BREAKING: redesigned slack library (@certik/skynet/slack)
+- Upgraded: @aws-sdk to support new S3 directory bucket capability
+- Deprecated: kafka / web3
+
+## 0.12.0
+
+- BREAKING: removed token module (@certik/skynet/token)
+- BREAKING: removed block module (@certik/skynet/block)
+- BREAKING: removed transaction module (@certik/skynet/transaction)
+- BREAKING: removed primitive module (@certik/skynet/primitive)
+- BREAKING: removed price module (@certik/skynet/price)
+- BREAKING: removed distributed-lock module (@certik/skynet/distributed-lock)
+
 ## 0.11.4
 
 - support api key in query string

package/kafka.js

@@ -1,10 +1,9 @@
 import meow from "meow";
 import { Kafka, logLevel } from "kafkajs";
 import { getEnvironment, getEnvOrThrow } from "./env.js";
-import { getJobName, getSelectorFlags, getSelectorDesc, toSelectorString } from "./selector.js";
+import { getSelectorFlags, getSelectorDesc, toSelectorString } from "./selector.js";
 import { createRecord, getRecordByKey, deleteRecordsByHashKey } from "./dynamodb.js";
 import { wait, exponentialRetry } from "./availability.js";
-import { useLock } from "./distributed-lock.js";
 import { getBinaryName } from "./cli.js";
 import { inline } from "./log.js";
 
@@ -219,8 +218,6 @@ ${getSelectorDesc(selector)}
         process.exit(0);
       }
 
-      await useLock({ name: getJobName(name, selectorFlags), ttl: 50, verbose });
-
       if (!from) {
         const prevId = await getProducerLatestId(name, selectorFlags);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@certik/skynet",
-  "version": "0.11.4",
+  "version": "0.13.0",
   "description": "Skynet Shared JS library",
   "type": "module",
   "main": "index.js",
@@ -15,13 +15,12 @@
     "node": ">= 18"
   },
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.409.0",
-    "@aws-sdk/client-s3": "^3.409.0",
-    "@aws-sdk/client-sqs": "^3.409.0",
-    "@aws-sdk/lib-dynamodb": "^3.409.0",
-    "@opensearch-project/opensearch": "^2.3.1",
-    "@slack/web-api": "^6.9.0",
-    "ably": "^1.2.44",
+    "@aws-sdk/client-dynamodb": "^3.478.0",
+    "@aws-sdk/client-s3": "^3.478.0",
+    "@aws-sdk/client-sqs": "^3.478.0",
+    "@aws-sdk/lib-dynamodb": "^3.478.0",
+    "@opensearch-project/opensearch": "^2.4.0",
+    "@slack/web-api": "^6.11.0",
     "bottleneck": "^2.19.5",
     "chalk": "^5.3.0",
     "execa": "^8.0.1",
@@ -29,16 +28,16 @@
     "kafkajs": "^2.2.4",
     "md5": "^2.3.0",
     "meow": "^12.1.1",
-    "snowflake-sdk": "^1.8.0",
-    "web3": "^4.1.1",
+    "snowflake-sdk": "^1.9.2",
+    "web3": "^4.3.0",
     "which": "^4.0.0"
   },
   "devDependencies": {
-    "ava": "^5.3.1",
-    "eslint": "^8.49.0",
-    "eslint-plugin-import": "^2.28.1",
-    "prettier": "^3.0.3",
-    "sinon": "^15.2.0"
+    "ava": "^6.0.1",
+    "eslint": "^8.56.0",
+    "eslint-plugin-import": "^2.29.1",
+    "prettier": "^3.1.1",
+    "sinon": "^17.0.1"
   },
   "license": "MIT",
   "publishConfig": {

package/slack.js

@@ -1,71 +1,16 @@
 import { WebClient } from "@slack/web-api";
 
-function getToken() {
-  return process.env.SKYNET_SLACK_TOKEN;
-}
-
-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");
-  }
-
+function getClient(token) {
   const client = new WebClient(token);
 
   return client;
 }
 
-async function findConversation(client, name) {
-  const { conversations } = client;
-
-  let channels = [];
-
-  let result = await conversations.list({
-    types: "public_channel,private_channel",
-    limit: 1000,
-  });
-
-  channels = channels.concat(result.channels);
-
-  while (result.response_metadata.next_cursor) {
-    result = await conversations.list({
-      types: "public_channel,private_channel",
-      cursor: result.response_metadata.next_cursor,
-      limit: 1000,
-    });
-
-    channels = channels.concat(result.channels);
-  }
-
-  for (const channel of channels) {
-    if (channel.name === name) {
-      const conversationId = channel.id;
-
-      return conversationId;
-    }
-  }
-
-  return null;
-}
-
-function isString(s) {
-  return typeof s === "string" || s instanceof String;
-}
-
-async function postMessage(channel, message, verbose) {
+// you can identify conversation ID at the bottom of the channel settings page
+async function postMessageToConversation({ conversationId, message, token, verbose }) {
   try {
-    const token = isString(channel) ? null : channel.token;
     const client = getClient(token);
 
-    let conversationId = isString(channel) ? await findConversation(client, channel) : channel.id;
-
-    if (!conversationId) {
-      throw new Error(
-        `cannot find slack public/private channel: ${channel}, you may have to invite the @CertiK Skynet bot to the channel`
-      );
-    }
-
     let post = {};
 
     if (typeof message === "string") {
@@ -75,7 +20,7 @@ async function postMessage(channel, message, verbose) {
     }
 
     if (verbose) {
-      console.log(`posting to slack channel ${channel} (${conversationId}):`, JSON.stringify(post, null, 2));
+      console.log(`posting to slack conversation ${conversationId}:`, JSON.stringify(post, null, 2));
     }
 
     await client.chat.postMessage({
@@ -89,4 +34,4 @@ async function postMessage(channel, message, verbose) {
   }
 }
 
-export { getClient, findConversation, postMessage };
+export { postMessageToConversation };

package/ably.d.ts

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

package/ably.js

@@ -1,35 +0,0 @@
-import Ably from "ably";
-import Bottleneck from "bottleneck/es5";
-import { ensureAndGet } from "./env.js";
-
-let ABLY;
-
-async function getAbly() {
-  if (!ABLY) {
-    ABLY = await new Promise((resolve) => {
-      const ably = new Ably.Realtime(ensureAndGet("ABLY_ROOT_API_KEY"));
-      ably.connection.on("connected", () => {
-        console.log("ably connection successful");
-        resolve(ably);
-      });
-    });
-  }
-  return ABLY;
-}
-
-export async function publishMessage(channel, messageName, messageData) {
-  const ably = await getAbly();
-  const channelObj = ably.channels.get(channel);
-
-  const messageDataJson = JSON.stringify(messageData);
-
-  try {
-    await channelObj.publish(messageName, messageDataJson);
-  } catch (error) {
-    console.error("error publishing to ably: ", error);
-  }
-}
-
-export const rateLimitedPublishMessage = new Bottleneck({
-  minTime: 1000 / 40,
-}).wrap(publishMessage);

package/block.d.ts

@@ -1,49 +0,0 @@
-// 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/block.js

@@ -1,82 +0,0 @@
-import { Web3 } from "web3";
-import { getEnvironment } from "./env.js";
-import { PROTOCOLS } from "./const.js";
-import { readFile } from "./s3.js";
-import { getRecordByKey } from "./dynamodb.js";
-
-const S3_BUCKET_NAME =
-  getEnvironment() === "prd" ? "certik-skynet" : "certik-skynet-dev";
-const INDEXER_STATE_TABLE = `skynet-${getEnvironment()}-indexer-state`;
-
-function leftPad3(num) {
-  if (num === 0) {
-    return "000";
-  } else if (num < 10) {
-    return "00" + String(num);
-  } else if (num < 100) {
-    return "0" + String(num);
-  } else {
-    return String(num);
-  }
-}
-
-function getBlockS3Path(protocol, height) {
-  return `chaindata/${protocol}/${Math.floor(height / 1_000_000)}/${leftPad3(
-    Math.floor(height / 1_000) % 1000
-  )}/${leftPad3(height % 1000)}.json`;
-}
-
-// We use this function instead of web3 because the gas limits on bsc exceed
-// the size supported by javascript numbers, and web3 does not support this
-async function getBlock(protocol, height) {
-  const body = {
-    jsonrpc: "2.0",
-    method: "eth_getBlockByNumber",
-    params: [`0x${height.toString(16)}`, true],
-    id: 1
-  };
-  const response = await fetch(PROTOCOLS[protocol].endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-
-  const { result: block } = await response.json();
-
-  return block;
-}
-
-async function getLatestBlockHeight(protocol) {
-  const web3 = new Web3(PROTOCOLS[protocol].endpoint);
-  const isSyncing = await web3.eth.isSyncing();
-
-  if (isSyncing) {
-    return isSyncing.currentBlock;
-  } else {
-    const latestBlock = await web3.eth.getBlock("latest");
-
-    return latestBlock.number;
-  }
-}
-
-async function getLatestS3BlockHeight(protocol) {
-  const name = `AMLBlockIndexerSince(protocol=${protocol})`;
-  const { value: height } = await getRecordByKey(INDEXER_STATE_TABLE, { name });
-  return height;
-}
-
-async function getBlockFromS3(protocol, height) {
-  const body = await readFile(S3_BUCKET_NAME, getBlockS3Path(protocol, height));
-
-  return JSON.parse(body);
-}
-
-export {
-  getLatestBlockHeight,
-  getBlock,
-  getBlockS3Path,
-  getLatestS3BlockHeight,
-  getBlockFromS3
-};

package/distributed-lock.d.ts

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

package/distributed-lock.js

@@ -1,109 +0,0 @@
-async function acquireLock(name, ttl) {
-  try {
-    const res = await fetch("http://localhost:8500/v1/session/create", {
-      method: "PUT",
-      body: JSON.stringify({
-        Name: name,
-        TTL: `${ttl}s`,
-        Behavior: "delete",
-      }),
-    });
-
-    if (res.ok) {
-      const { ID: id } = await res.json();
-
-      return id;
-    } else {
-      console.log(res, await res.text());
-
-      return null;
-    }
-  } catch (fetchErr) {
-    // console.log("error fetching", fetchErr);
-
-    return null;
-  }
-}
-
-async function renewLock(uid) {
-  try {
-    const res = await fetch(`http://localhost:8500/v1/session/renew/${uid}`, {
-      method: "PUT",
-    });
-
-    if (res.ok) {
-      return uid;
-    } else {
-      console.log(res, await res.text());
-
-      return null;
-    }
-  } catch (fetchErr) {
-    // console.log("error fetching", fetchErr);
-
-    return null;
-  }
-}
-
-async function hasLock(name, uid = null) {
-  try {
-    const res = await fetch(`http://localhost:8500/v1/session/list`);
-
-    if (res.ok) {
-      const sessions = await res.json();
-
-      const sessionsWithTheSameName = sessions.filter((s) => s.Name === name);
-
-      if (!uid) {
-        return sessionsWithTheSameName.length === 0;
-      }
-
-      if (sessionsWithTheSameName.length !== 1) {
-        return false;
-      }
-
-      // only one should have the same uid
-      return sessionsWithTheSameName[0].ID === uid;
-    } else {
-      console.log(await res.text());
-
-      return true;
-    }
-  } catch (fetchErr) {
-    // console.log("error fetching", fetchErr);
-
-    return true;
-  }
-}
-
-export async function useLock({ name, ttl, verbose }) {
-  const lockWarningMessage = `only one process with the same lock name ${name} should be running, terminate current process`;
-
-  const lockAvailable = await hasLock(name);
-
-  if (!lockAvailable) {
-    console.log(lockWarningMessage);
-    process.exit(0);
-  }
-
-  let uid = await acquireLock(name, ttl);
-
-  setInterval(async () => {
-    if (!(await hasLock(name, uid))) {
-      console.log(lockWarningMessage);
-      process.exit(0);
-    }
-
-    if (uid) {
-      if (verbose) {
-        console.log("renewing", name, uid);
-      }
-
-      uid = await renewLock(uid);
-    } else {
-      uid = await acquireLock(name, ttl);
-    }
-  }, (ttl * 1000) / 2);
-
-  return uid;
-}

package/metric.d.ts

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

package/metric.js

@@ -1,60 +0,0 @@
-import { getDocClient } from "./dynamodb.js";
-
-/* Assume table has name/timestamp/value fields */
-
-export async function getMetricAt(tableName, name, timestamp) {
-  const docClient = getDocClient();
-
-  const query = await docClient
-    .query({
-      TableName: tableName,
-      KeyConditionExpression: "#name = :name and #timestamp <= :timestamp",
-      ExpressionAttributeNames: {
-        "#name": "name",
-        "#timestamp": "timestamp"
-      },
-      ExpressionAttributeValues: {
-        ":name": name,
-        ":timestamp": timestamp
-      },
-      Limit: 1,
-      ScanIndexForward: false
-    })
-    .promise();
-
-  if (query.Count > 0) {
-    const { value } = query.Items[0];
-
-    return value;
-  } else {
-    return null;
-  }
-}
-
-export async function getMetricPreviousValue(tableName, name, timestamp) {
-  const docClient = getDocClient();
-
-  const query = await docClient
-    .query({
-      TableName: tableName,
-      KeyConditionExpression: "#name = :name and #timestamp < :timestamp",
-      ExpressionAttributeNames: {
-        "#timestamp": "timestamp",
-        "#name": "name"
-      },
-      ExpressionAttributeValues: {
-        ":timestamp": timestamp,
-        ":name": name
-      },
-      Limit: 1,
-      ScanIndexForward: false
-    })
-    .promise();
-
-  if (query.Count === 0) {
-    return 0;
-  } else {
-    const { value } = query.Items[0];
-    return value;
-  }
-}

package/price.d.ts

@@ -1,8 +0,0 @@
-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/price.js

@@ -1,46 +0,0 @@
-import { QueryCommand } from "@aws-sdk/lib-dynamodb";
-import { getDocClient } from "./dynamodb.js";
-
-async function queryPrice(tableName, address, timestamp, op = "<") {
-  const docClient = getDocClient();
-
-  return await docClient.send(
-    new QueryCommand({
-      TableName: tableName,
-      KeyConditionExpression: `#address = :address and #timestamp ${op} :timestamp`,
-      ExpressionAttributeNames: {
-        "#timestamp": "timestamp",
-        "#address": "address",
-      },
-      ExpressionAttributeValues: {
-        ":timestamp": timestamp,
-        ":address": address,
-      },
-      Limit: 1,
-      ScanIndexForward: false,
-    }),
-  );
-}
-
-async function getPricePreviousRecord(tableName, address, timestamp) {
-  const query = await queryPrice(tableName, address, timestamp, "<");
-
-  if (query.Count === 0) {
-    return null;
-  } else {
-    return query.Items[0];
-  }
-}
-
-async function getPriceClosestTo(tableName, address, timestamp) {
-  const query = await queryPrice(tableName, address, timestamp, "<=");
-
-  if (query.Count === 0) {
-    return 0;
-  } else {
-    const { price } = query.Items[0];
-    return price;
-  }
-}
-
-export { getPriceClosestTo, getPricePreviousRecord };

package/primitive.d.ts

@@ -1,29 +0,0 @@
-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/primitive.js

@@ -1,78 +0,0 @@
-async function getOverrides(docClient, projectId, address, log, primitive) {
-  try {
-    console.log("ProjectId:" + projectId + " address:" + address);
-
-    const whitelist = [];
-    const queryProjectOverrides = await docClient
-      .get({
-        TableName: "skynet-prd-primitive-manual-overrides",
-        Key: {
-          primitive: primitive,
-          overrideId: "project/" + projectId,
-        },
-      })
-      .promise();
-    if (queryProjectOverrides.Item && queryProjectOverrides.Item.whitelist) {
-      whitelist.push(...queryProjectOverrides.Item.whitelist);
-    }
-
-    const queryAddressOverrides = await docClient
-      .get({
-        TableName: "skynet-prd-primitive-manual-overrides",
-        Key: {
-          primitive: primitive,
-          overrideId: "address/" + address,
-        },
-      })
-      .promise();
-
-    if (queryAddressOverrides.Item && queryAddressOverrides.Item.whitelist) {
-      console.log(queryAddressOverrides.Item.whitelist);
-      whitelist.push(...queryAddressOverrides.Item.whitelist);
-    }
-    if (whitelist.length === 0) {
-      log(
-        "ProjectId " + projectId + " ,Address " + address + " has no override"
-      );
-    }
-    console.log("Whitelist:" + whitelist);
-    return whitelist;
-  } catch (scanFeedErr) {
-    log("scan feed error, check dynamodb table", scanFeedErr);
-    return null;
-  }
-}
-
-async function overrideScoreAndIssues(
-  docClient,
-  projectId,
-  address,
-  score,
-  issues,
-  log,
-  primitive
-) {
-  const overrides = await getOverrides(
-    docClient,
-    projectId,
-    address,
-    log,
-    primitive
-  );
-
-  issues = issues.filter((issue) => {
-    if (overrides.includes(issue.code)) {
-      score += issue.reduction;
-      return false;
-    } else return true;
-  });
-  return {
-    score,
-    issues,
-  };
-}
-
-export {
-  getOverrides,
-  overrideScoreAndIssues,
-};

package/scan.d.ts

@@ -1,47 +0,0 @@
-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/scan.js

@@ -1,74 +0,0 @@
-import { exponentialRetry, wait } from "./availability.js";
-import { PROTOCOLS } from "./const.js";
-
-const BATCH_SIZE = 10_000; // Max number of transactions fetched from scan api at once
-
-function getScanApiEndpoint(protocol, addr, startBlock = 0, endBlock = null, offset=BATCH_SIZE) {
-  const { endpoint, key } = PROTOCOLS[protocol].scanApi;
-  let url = `${endpoint}?module=account&action=txlist&address=${addr}&apikey=${key}&sort=asc&startblock=${startBlock}&page=1&offset=${offset}`;
-
-  if (endBlock) {
-    url += `&endblock=${endBlock}`;
-  }
-
-  return url;
-}
-
-async function fetchTxs(protocol, addr, since, to, offset) {
-  const url = getScanApiEndpoint(protocol, addr, since, to, offset);
-
-  try {
-    const res = await fetch(url);
-    const scanJSON = await res.json();
-    return scanJSON.result;
-  } catch (err) {
-    console.log(`error fetching txs: ${err}`)
-    return null;
-  }
-}
-
-async function fetchTxsWithRetry(protocol, addr, since, to, offset, verbose) {
-  const txs = await exponentialRetry(
-    async () => fetchTxs(protocol, addr, since, to, offset),
-    { maxRetry: 6, test: Array.isArray, verbose }
-  )
-
-  return txs;
-}
-
-async function streamTxs(address, since, to, callback, verbose) {
-  let startBlock = since;
-  let hasMorePage = true;
-  let lastTxHash = null;
-
-  const [protocol, addr] = address.split(":");
-
-  while (hasMorePage) {
-    const txs = await fetchTxs(protocol, addr, startBlock, to, BATCH_SIZE, verbose);
-    console.log(`start block=${since}, total items=${txs.length}`);
-
-    // This will only ever happen if the total number of txs is a multiple of our batch size
-    if (txs.length === 0) {
-      break;
-    }
-
-    // If our start block overlaps with the last request's end block, then we may have some overlapping txs
-    // To avoid adding those txs to the db twice, we filter them out
-    const newTxsStartIdx = txs.indexOf(({ hash }) => hash === lastTxHash);
-
-    const newTxs = txs.slice(newTxsStartIdx !== -1 ? newTxsStartIdx : 0);
-
-    for (const tx of newTxs) {
-      callback(tx);
-    }
-
-    hasMorePage = txs.length === BATCH_SIZE;
-
-    startBlock = parseInt(txs[txs.length - 1].blockNumber, 10) + 1;
-    lastTxHash = txs[txs.length - 1].hash;
-
-    await wait(2000);
-  }
-}
-
-export { streamTxs, fetchTxs, fetchTxsWithRetry };

package/token.d.ts

@@ -1,5 +0,0 @@
-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/token.js

@@ -1,46 +0,0 @@
-import { getEnvironment } from "./env.js";
-import { getPriceClosestTo } from "./price.js";
-import BigNumber from "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);
-}
-
-export {
-  getTokenPriceAt,
-  toNativeDecimal,
-  toHumanDecimal,
-};

package/transaction.d.ts

@@ -1,30 +0,0 @@
-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/transaction.js

@@ -1,42 +0,0 @@
-import { PROTOCOLS } from "./const.js";
-import { exponentialRetry } from "./availability.js";
-
-async function getTxReceipt(protocol, txHash, verbose = false) {
-  const { endpoint } = PROTOCOLS[protocol];
-
-  console.log("got endpoint", protocol, endpoint);
-
-  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;
-}
-
-export {
-  getTxReceipt
-};