@certik/skynet 0.20.2 → 0.22.0

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+declare function getBinaryName(): string;
+declare function detectSkynetDirectory(): string;
+declare function detectWorkingDirectory(): string;
+declare function detectBin(): string;
+export { getBinaryName, detectSkynetDirectory, detectWorkingDirectory, detectBin };
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":"AAGA,iBAAS,aAAa,WAKrB;AAED,iBAAS,qBAAqB,WAE7B;AAED,iBAAS,sBAAsB,WAK9B;AAsBD,iBAAS,SAAS,WAIjB;AAED,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,SAAS,EAAE,CAAC"}

package/dist/cli.js

@@ -0,0 +1,86 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// cli.ts
+import path from "path";
+import fs from "fs";
+function getBinaryName() {
+  const binaryNameParts = process.argv[1].split(path.sep);
+  const binaryName = binaryNameParts[binaryNameParts.length - 1];
+  return binaryName;
+}
+function detectSkynetDirectory() {
+  return detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
+}
+function detectWorkingDirectory() {
+  const wd = detectDirectory(process.argv[1], "package.json");
+  const skynetd = detectDirectory(process.argv[1], "SkynetAPIDefinitions.yml");
+  return wd.slice(skynetd.length + path.sep.length).replace(path.sep, "/");
+}
+function detectDirectory(fullBinPath, sentinel = "package.json") {
+  let parentFolder = path.dirname(fullBinPath);
+  while (parentFolder) {
+    const sentinelPath = path.join(parentFolder, sentinel);
+    if (fs.existsSync(sentinelPath)) {
+      return parentFolder;
+    }
+    const newParentFolder = path.dirname(parentFolder);
+    if (newParentFolder === parentFolder) {
+      break;
+    }
+    parentFolder = newParentFolder;
+  }
+  throw new Error("Cannot detect current working directory");
+}
+function detectBin() {
+  const wd = detectDirectory(process.argv[1], "package.json");
+  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
+}
+export {
+  getBinaryName,
+  detectWorkingDirectory,
+  detectSkynetDirectory,
+  detectBin
+};

package/dist/const.d.ts

@@ -0,0 +1,35 @@
+type Protocol = {
+    nativeTokenName: string;
+    nativeTokenSymbol: string;
+    nativeTokenDecimals: number;
+    nativeTokenAddress: string;
+    nativeTokenLogo?: string;
+    nativeTokenCoinGeckoId?: string;
+    nativeTokenCmcId?: number;
+    endpoint: string;
+    backupEndpoint?: string;
+    archiveEndpoint?: string;
+    tokenStandard: string;
+    scanApi?: {
+        endpoint: string;
+        key?: string;
+    };
+    multiCallProvider?: string;
+    scanUrl?: string;
+    chainId: number;
+};
+type TimeIntervals = {
+    SECOND: number;
+    MINUTE: number;
+    HOUR: number;
+    DAY: number;
+    WEEK: number;
+    YEAR: number;
+};
+declare const PROTOCOLS: Record<string, Protocol>;
+declare const TIME: {
+    BY_MS: TimeIntervals;
+    BY_S: TimeIntervals;
+};
+export { PROTOCOLS, TIME };
+//# sourceMappingURL=const.d.ts.map

package/dist/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../const.ts"],"names":[],"mappings":"AAEA,KAAK,QAAQ,GAAG;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAOF,QAAA,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAoHvC,CAAC;AAEF,QAAA,MAAM,IAAI,EAAE;IACV,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,aAAa,CAAC;CAkBrB,CAAC;AAEF,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC"}

package/dist/const.js

@@ -0,0 +1,207 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// env.ts
+function ensureAndGet(envName, defaultValue) {
+  return process.env[envName] || defaultValue;
+}
+function getEnvironment() {
+  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
+}
+function getEnvOrThrow(envName) {
+  if (!process.env[envName]) {
+    throw new Error(`Must set environment variable ${envName}`);
+  }
+  return process.env[envName];
+}
+function isProduction() {
+  return getEnvironment() === "prd";
+}
+function isDev() {
+  return getEnvironment() === "dev";
+}
+// const.ts
+function getNodeRealApiKey(identifier) {
+  return ensureAndGet(`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`) ?? ensureAndGet("SKYNET_NODEREAL_API_KEY");
+}
+var PROTOCOLS = {
+  eth: {
+    nativeTokenName: "Ethereum",
+    nativeTokenSymbol: "ETH",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "eth:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/eth:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "ethereum",
+    nativeTokenCmcId: 1027,
+    endpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
+    archiveEndpoint: `https://eth-mainnet.nodereal.io/v1/${getNodeRealApiKey("ETH")}`,
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.etherscan.io/api",
+      key: ensureAndGet("SKYNET_ETHER_SCAN_API_KEY")
+    },
+    multiCallProvider: "0xCa731e0f33Afbcfa9363d6F7449d1f5447d10C80",
+    scanUrl: "https://etherscan.io/",
+    chainId: 1
+  },
+  bsc: {
+    nativeTokenName: "Binance Coin",
+    nativeTokenSymbol: "BNB",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "bsc:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/bsc:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "binance-coin",
+    nativeTokenCmcId: 1839,
+    endpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
+    archiveEndpoint: `https://bsc-mainnet.nodereal.io/v1/${getNodeRealApiKey("BSC")}`,
+    tokenStandard: "BEP20",
+    scanApi: {
+      endpoint: "https://api.bscscan.com/api",
+      key: ensureAndGet("SKYNET_BSC_SCAN_API_KEY")
+    },
+    multiCallProvider: "0xe7144e57d832c9005D252f415d205b4b8D78228e",
+    scanUrl: "https://bscscan.com/",
+    chainId: 56
+  },
+  polygon: {
+    nativeTokenName: "Polygon",
+    nativeTokenSymbol: "MATIC",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/polygon:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "matic-network",
+    nativeTokenCmcId: 3890,
+    endpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
+    archiveEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
+    backupEndpoint: `https://polygon-mainnet.nodereal.io/v1/${getNodeRealApiKey("POLYGON")}`,
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.polygonscan.com/api",
+      key: ensureAndGet("SKYNET_POLYGON_SCAN_API_KEY")
+    },
+    multiCallProvider: "0x8eC86392e0aDB57d00fDffbA39b8870e107c0757",
+    scanUrl: "https://polygonscan.com/",
+    chainId: 137
+  },
+  heco: {
+    nativeTokenName: "Heco",
+    nativeTokenSymbol: "HT",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "heco:0x0000000000000000000000000000000000000000",
+    endpoint: `https://http-mainnet.hecochain.com`,
+    tokenStandard: "HRC20",
+    multiCallProvider: "0xe7144e57d832c9005d252f415d205b4b8d78228e",
+    scanUrl: "https://hecoinfo.com/",
+    chainId: 128
+  },
+  avax: {
+    nativeTokenName: "Avalanche",
+    nativeTokenSymbol: "AVAX",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "avax:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/avax:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "avalanche-2",
+    nativeTokenCmcId: 5805,
+    endpoint: `https://api.avax.network/ext/bc/C/rpc`,
+    tokenStandard: "ARC20",
+    scanApi: {
+      endpoint: "https://api.snowtrace.io/api",
+      key: ensureAndGet("SKYNET_AVASCAN_API_KEY")
+    },
+    scanUrl: "https://snowtrace.io/",
+    chainId: 43114
+  },
+  ftm: {
+    nativeTokenName: "Fantom",
+    nativeTokenSymbol: "FTM",
+    nativeTokenDecimals: 18,
+    nativeTokenAddress: "ftm:0x0000000000000000000000000000000000000000",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/ftm:0x0000000000000000000000000000000000000000.png`,
+    nativeTokenCoinGeckoId: "fantom",
+    nativeTokenCmcId: 3513,
+    endpoint: `https://rpcapi.fantom.network`,
+    tokenStandard: "ERC20",
+    scanApi: {
+      endpoint: "https://api.ftmscan.com/api",
+      key: ensureAndGet("SKYNET_FTMSCAN_API_KEY")
+    },
+    scanUrl: "https://ftmscan.com/",
+    chainId: 250
+  },
+  algo: {
+    nativeTokenName: "Algorand",
+    nativeTokenSymbol: "ALGO",
+    nativeTokenDecimals: 6,
+    nativeTokenAddress: "algo:native",
+    nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/algo:native.png`,
+    nativeTokenCoinGeckoId: "algorand",
+    nativeTokenCmcId: 4030,
+    endpoint: "https://algo-node.certik-skynet.com/",
+    tokenStandard: "ASA",
+    chainId: 1300
+  }
+};
+var TIME = {
+  BY_MS: {
+    SECOND: 1000,
+    MINUTE: 1000 * 60,
+    HOUR: 1000 * 60 * 60,
+    DAY: 1000 * 60 * 60 * 24,
+    WEEK: 1000 * 60 * 60 * 24 * 7,
+    YEAR: 1000 * 60 * 60 * 24 * 365
+  },
+  BY_S: {
+    SECOND: 1,
+    MINUTE: 60,
+    HOUR: 60 * 60,
+    DAY: 60 * 60 * 24,
+    WEEK: 60 * 60 * 24 * 7,
+    YEAR: 60 * 60 * 24 * 365
+  }
+};
+export {
+  TIME,
+  PROTOCOLS
+};

package/dist/databricks.d.ts

@@ -0,0 +1,4 @@
+import type { DBSQLParameterValue } from "@databricks/sql/dist/DBSQLParameter.js";
+declare function executeSql<T>(sql: string, bindings: Record<string, DBSQLParameterValue>): Promise<T[]>;
+export { executeSql };
+//# sourceMappingURL=databricks.d.ts.map

package/dist/databricks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databricks.d.ts","sourceRoot":"","sources":["../databricks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAqBlF,iBAAe,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,gBAuCtF;AAiBD,OAAO,EAAE,UAAU,EAAE,CAAC"}