@certik/skynet 0.22.1 → 0.22.3

package/dist/availability.d.ts

@@ -21,4 +21,3 @@ export declare function memoize<F extends AnyAsyncFunction>(func: F, options?: {
     lruMaxSize?: number;
 }): F;
 export { pThrottle as throttle };
-//# sourceMappingURL=availability.d.ts.map

package/dist/availability.js

@@ -1,63 +1,133 @@
+// src/object-hash.ts
+import xh from "@node-rs/xxhash";
+function getHash(obj) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
+}
+function hash(obj, xxh3) {
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
+}
+function arrayHash(array, xxh3) {
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
+}
+function setHash(_set, _xxh3) {
+  throw new Error("Set hashing not implemented");
+}
+function mapHash(map, xxh3) {
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+function objectHash(obj, xxh3) {
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+
+// src/availability.ts
 import pThrottle from "p-throttle";
 import pMemoize from "p-memoize";
 import QuickLRU from "quick-lru";
-import { getHash } from "./object-hash";
-export async function wait(time) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, time);
-    });
-}
-export async function exponentialRetry(func, { maxRetry, initialDuration, growFactor, test, verbose, }) {
-    let retries = maxRetry;
-    let duration = initialDuration || 5000;
-    const growFactorFinal = growFactor || 2;
-    let result = await func();
-    while (!test(result) && retries > 0) {
-        if (verbose) {
-            console.log("failed attempt result", result);
-            console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
-        }
+async function wait(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+async function exponentialRetry(func, {
+  maxRetry,
+  initialDuration,
+  growFactor,
+  test,
+  verbose
+}) {
+  let retries = maxRetry;
+  let duration = initialDuration || 5000;
+  const growFactorFinal = growFactor || 2;
+  let result = await func();
+  while (!test(result) && retries > 0) {
+    if (verbose) {
+      console.log("failed attempt result", result);
+      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
+    }
+    retries = retries - 1;
+    await wait(duration);
+    result = await func();
+    duration = duration * growFactorFinal;
+  }
+  if (verbose) {
+    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
+  }
+  return result;
+}
+function withRetry(func, options) {
+  let retries = options?.maxRetry || 3;
+  let duration = options?.initialDuration || 500;
+  const growFactorFinal = options?.growFactor || 2;
+  return async (...args) => {
+    do {
+      try {
+        return await func(...args);
+      } catch (error) {
         retries = retries - 1;
+        if (retries <= 0) {
+          throw error;
+        }
         await wait(duration);
-        result = await func();
         duration = duration * growFactorFinal;
-    }
-    if (verbose) {
-        console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
-    }
-    return result;
-}
-export function withRetry(func, options) {
-    let retries = options?.maxRetry || 3;
-    let duration = options?.initialDuration || 500;
-    const growFactorFinal = options?.growFactor || 2;
-    return (async (...args) => {
-        do {
-            try {
-                return await func(...args);
-            }
-            catch (error) {
-                retries = retries - 1;
-                if (retries <= 0) {
-                    throw error;
-                }
-                await wait(duration);
-                duration = duration * growFactorFinal;
-            }
-        } while (retries > 0);
-        throw new Error("unreachable");
-    });
-}
-export function memoize(func, options) {
-    if (!options) {
-        options = {};
-    }
-    if (!options.cache) {
-        options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 10000 });
-    }
-    if (!options.cacheKey) {
-        options.cacheKey = (args) => getHash(args);
-    }
-    return pMemoize(func, options);
+      }
+    } while (retries > 0);
+    throw new Error("unreachable");
+  };
+}
+function memoize(func, options) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.cache) {
+    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
+  }
+  if (!options.cacheKey) {
+    options.cacheKey = (args) => getHash(args);
+  }
+  return pMemoize(func, options);
 }
-export { pThrottle as throttle };
+export {
+  withRetry,
+  wait,
+  pThrottle as throttle,
+  memoize,
+  exponentialRetry
+};

package/dist/cli.d.ts

@@ -3,4 +3,3 @@ 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.js

@@ -1,37 +1,41 @@
+// src/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;
+  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");
+  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, "/");
+  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) {
-        // check if parentFolder length is greater than 0
-        const sentinelPath = path.join(parentFolder, sentinel);
-        if (fs.existsSync(sentinelPath)) {
-            return parentFolder;
-        }
-        const newParentFolder = path.dirname(parentFolder);
-        if (newParentFolder === parentFolder) {
-            // we have reached the root folder
-            break;
-        }
-        parentFolder = newParentFolder;
+  let parentFolder = path.dirname(fullBinPath);
+  while (parentFolder) {
+    const sentinelPath = path.join(parentFolder, sentinel);
+    if (fs.existsSync(sentinelPath)) {
+      return parentFolder;
     }
-    throw new Error("Cannot detect current working directory");
+    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, "/");
+  const wd = detectDirectory(process.argv[1], "package.json");
+  return process.argv[1].slice(wd.length + path.sep.length).replace(path.sep, "/");
 }
-export { getBinaryName, detectSkynetDirectory, detectWorkingDirectory, detectBin };
+export {
+  getBinaryName,
+  detectWorkingDirectory,
+  detectSkynetDirectory,
+  detectBin
+};

package/dist/const.d.ts

@@ -32,4 +32,3 @@ declare const TIME: {
     BY_S: TimeIntervals;
 };
 export { PROTOCOLS, TIME };
-//# sourceMappingURL=const.d.ts.map

package/dist/const.js

@@ -1,141 +1,162 @@
-import { ensureAndGet } from "./env";
+// src/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";
+}
+// src/const.ts
 function getNodeRealApiKey(identifier) {
-    // NodeReal API keys are different for each NodeReal app
-    return ensureAndGet(`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`) ?? ensureAndGet("SKYNET_NODEREAL_API_KEY");
+  return ensureAndGet(`SKYNET_NODEREAL_API_${identifier.toUpperCase()}_KEY`) ?? ensureAndGet("SKYNET_NODEREAL_API_KEY");
 }
-const PROTOCOLS = {
-    eth: {
-        nativeTokenName: "Ethereum",
-        nativeTokenSymbol: "ETH",
-        nativeTokenDecimals: 18,
-        nativeTokenAddress: "eth:0x0000000000000000000000000000000000000000",
-        nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/eth:0x0000000000000000000000000000000000000000.png`, // TODO: Can replace domain if needed
-        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,
+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")
     },
-    bsc: {
-        nativeTokenName: "Binance Coin",
-        nativeTokenSymbol: "BNB",
-        nativeTokenDecimals: 18,
-        nativeTokenAddress: "bsc:0x0000000000000000000000000000000000000000",
-        nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/bsc:0x0000000000000000000000000000000000000000.png`, // TODO: Can replace domain if needed
-        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,
+    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")
     },
-    polygon: {
-        nativeTokenName: "Polygon",
-        nativeTokenSymbol: "MATIC",
-        nativeTokenDecimals: 18,
-        nativeTokenAddress: "polygon:0x0000000000000000000000000000000000000000",
-        nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/polygon:0x0000000000000000000000000000000000000000.png`, // TODO: Can replace domain if needed
-        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,
+    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")
     },
-    heco: {
-        nativeTokenName: "Heco",
-        nativeTokenSymbol: "HT",
-        nativeTokenDecimals: 18,
-        nativeTokenAddress: "heco:0x0000000000000000000000000000000000000000",
-        endpoint: `https://http-mainnet.hecochain.com`, // use heco public RPC node
-        tokenStandard: "HRC20",
-        multiCallProvider: "0xe7144e57d832c9005d252f415d205b4b8d78228e",
-        scanUrl: "https://hecoinfo.com/",
-        chainId: 128,
+    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")
     },
-    avax: {
-        nativeTokenName: "Avalanche",
-        nativeTokenSymbol: "AVAX",
-        nativeTokenDecimals: 18,
-        nativeTokenAddress: "avax:0x0000000000000000000000000000000000000000",
-        nativeTokenLogo: `https://d1w63vqp8iwj2x.cloudfront.net/avax:0x0000000000000000000000000000000000000000.png`, // TODO: Can replace domain if needed
-        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`, // TODO: Can replace domain if needed
-        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,
+    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
+  }
 };
-const 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,
-    },
+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
 };
-export { PROTOCOLS, TIME };

package/dist/databricks.d.ts

@@ -1,4 +1,3 @@
 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