@certik/skynet 0.20.2 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.22.0
+
+- Added TypeScript build system using Bun for fast compilation
+- Added individual module exports for all library components
+- Users can now import specific modules: `import { util } from '@certik/skynet/util'`
+- Added TypeScript declaration files generation
+- Enhanced package.json exports for better ESM support
+- Added .gitignore for build artifacts
+
+## 0.21.0
+
+- BREAKING: Remove support for web3.js.
+- Add `debug` log level to `log` library. They will only be printed when `NODE_ENV` is set to `development`.
+- Hide all logs from `log` library when `NODE_ENV` is set to `test`.
+- Add `throttle` and `memoize` to `availability` library.
+- Add `object-hash` library for getting hash of an object. Based on xxhash algorithm.
+
 ## 0.20.2
 
 - Make `options` in `withRetry` function optional

package/abi.ts

@@ -1,6 +1,4 @@
-import type { AbiFunctionFragment } from "web3";
-
-export const ERC20: AbiFunctionFragment[] = [
+export const ERC20 = [
   {
     constant: true,
     inputs: [],
@@ -222,7 +220,7 @@ export const ERC20: AbiFunctionFragment[] = [
   },
 ];
 
-export const ERC721: AbiFunctionFragment[] = [
+export const ERC721 = [
   {
     inputs: [
       {

package/api.ts

@@ -2,10 +2,10 @@ import osModule from "os";
 import express from "express";
 import type { Request, Response, NextFunction } from "express";
 import meow from "meow";
-import { getSelectorDesc, getSelectorFlags } from "./selector.ts";
-import { isProduction } from "./env.ts";
-import { inline } from "./log.ts";
-import type { Selector } from "./selector.ts";
+import { getSelectorDesc, getSelectorFlags } from "./selector";
+import { isProduction } from "./env";
+import { inline } from "./log";
+import type { Selector } from "./selector";
 
 export type Middleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
 
@@ -23,7 +23,7 @@ type Serve = {
   apiKey?: string | Record<string, string>;
 };
 
-async function logStartMiddleware(req: Request, res: Response, next: NextFunction) {
+async function logStartMiddleware(_: Request, res: Response, next: NextFunction) {
   const start = new Date();
 
   res.set("x-requested-at", start.toISOString());
@@ -31,7 +31,7 @@ async function logStartMiddleware(req: Request, res: Response, next: NextFunctio
   next();
 }
 
-async function contextMiddleware(req: Request, res: Response, next: NextFunction) {
+async function contextMiddleware(_: Request, res: Response, next: NextFunction) {
   res.set("x-instance-id", osModule.hostname());
 
   next();
@@ -213,7 +213,7 @@ ${getSelectorDesc(selector)}
 
   if (!routes.some((r) => r.path === "/" && r.method?.toUpperCase() === "GET")) {
     // for health check
-    app.get("/", (req, res) => {
+    app.get("/", (_, res) => {
       res.send("ok");
     });
   }

package/app.ts

@@ -1,18 +1,12 @@
 import { EOL } from "os";
-import { createIndexerApp, createModeIndexerApp } from "./indexer.ts";
-import type {
-  IndexerStateValue,
-  State,
-  ModeBuildFunction,
-  StatelessBuildFunction,
-  ValidateFunction,
-} from "./indexer.ts";
-import { createDeploy, createModeDeploy } from "./deploy.ts";
-import type { Env } from "./deploy.ts";
+import { createIndexerApp, createModeIndexerApp } from "./indexer";
+import type { IndexerStateValue, State, ModeBuildFunction, StatelessBuildFunction, ValidateFunction } from "./indexer";
+import { createDeploy, createModeDeploy } from "./deploy";
+import type { Env } from "./deploy";
 import { startApiApp } from "./api.js";
-import type { Middleware } from "./api.ts";
+import type { Middleware } from "./api";
 import { getBinaryName, detectBin, detectWorkingDirectory } from "./cli.js";
-import type { Selector } from "./selector.ts";
+import type { Selector } from "./selector";
 import type { Request, Response, Application } from "express";
 
 type RouteDefinition = {

package/availability.ts

@@ -1,3 +1,12 @@
+import pThrottle from "p-throttle";
+import pMemoize, { type CacheStorage } from "p-memoize";
+import type { AsyncReturnType } from "type-fest";
+import QuickLRU from "quick-lru";
+import { getHash } from "./object-hash";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export declare type AnyAsyncFunction = (...arguments_: readonly any[]) => Promise<any>;
+
 export async function wait(time: number) {
   return new Promise((resolve) => {
     setTimeout(resolve, time);
@@ -47,28 +56,49 @@ export async function exponentialRetry<T>(
   return result;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function withRetry<F extends (...args: any[]) => any>(
+export function withRetry<F extends AnyAsyncFunction>(
   func: F,
   options?: { maxRetry?: number; initialDuration?: number; growFactor?: number },
-) {
+): F {
   let retries = options?.maxRetry || 3;
   let duration = options?.initialDuration || 500;
   const growFactorFinal = options?.growFactor || 2;
 
-  return async (...args: Parameters<F>): Promise<ReturnType<F>> => {
+  return (async (...args: Parameters<F>): Promise<AsyncReturnType<F>> => {
     do {
       try {
         return await func(...args);
       } catch (error) {
         retries = retries - 1;
-        if (retries === 0) {
+        if (retries <= 0) {
           throw error;
         }
         await wait(duration);
         duration = duration * growFactorFinal;
       }
-    } while (retries >= 0);
+    } while (retries > 0);
     throw new Error("unreachable");
-  };
+  }) as F;
+}
+
+export function memoize<F extends AnyAsyncFunction>(
+  func: F,
+  options?: {
+    cache?: CacheStorage<string, AsyncReturnType<F>> | false;
+    cacheKey?: (args: Parameters<F>) => string;
+    lruMaxSize?: number;
+  },
+) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.cache) {
+    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 10000 });
+  }
+  if (!options.cacheKey) {
+    options.cacheKey = (args: Parameters<F>) => getHash(args);
+  }
+  return pMemoize<F, string>(func, options);
 }
+
+export { pThrottle as throttle };

package/const.ts

@@ -1,4 +1,4 @@
-import { ensureAndGet } from "./env.ts";
+import { ensureAndGet } from "./env";
 
 type Protocol = {
   nativeTokenName: string;

package/date.ts

@@ -1,4 +1,4 @@
-import { arrayGroup } from "./util.ts";
+import { arrayGroup } from "./util";
 
 const MS_IN_A_DAY = 3600 * 24 * 1000;
 

package/deploy.ts

@@ -4,10 +4,10 @@ import { execa } from "execa";
 import meow from "meow";
 import chalk from "chalk";
 import which from "which";
-import { getJobName, getSelectorDesc, getSelectorFlags } from "./selector.ts";
-import type { Selector } from "./selector.ts";
-import { getEnvOrThrow } from "./env.ts";
-import { getBinaryName, detectSkynetDirectory } from "./cli.ts";
+import { getJobName, getSelectorDesc, getSelectorFlags } from "./selector";
+import type { Selector } from "./selector";
+import { getEnvOrThrow } from "./env";
+import { getBinaryName, detectSkynetDirectory } from "./cli";
 import type { Writable } from "stream";
 
 export type Env = {

package/dist/abi.d.ts

@@ -0,0 +1,112 @@
+export declare const ERC20: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+} | {
+    name: string;
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];
+export declare const ERC721: ({
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+} | {
+    constant: boolean;
+    inputs: any[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    payable?: undefined;
+})[];
+export declare const BEP20: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+} | {
+    name: string;
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];
+//# sourceMappingURL=abi.d.ts.map

package/dist/abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../abi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4NjB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsVlB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAQ,CAAC"}