@gearbox-protocol/sdk 9.0.3 → 9.1.0

package/dist/cjs/dev/RevolverTransport.js

@@ -0,0 +1,195 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RevolverTransport_exports = {};
+__export(RevolverTransport_exports, {
+  NoAvailableTransportsError: () => NoAvailableTransportsError,
+  RevolverTransport: () => RevolverTransport
+});
+module.exports = __toCommonJS(RevolverTransport_exports);
+var import_viem = require("viem");
+var import_providers = require("./providers.js");
+class NoAvailableTransportsError extends import_viem.BaseError {
+  constructor() {
+    super("no available transports");
+  }
+}
+class RevolverTransport {
+  #transports;
+  #index = 0;
+  #config;
+  overrides;
+  /**
+   * Create a new RevolverTransport
+   * RevolverTransport usues several RPC providers and rotates between them when requests fail
+   * Failed transport goes into temporary cooldown, after which it can be tried again
+   * When all transports are on cooldown, the transport will throw a NoAvailableTransportsError
+   * @param config
+   * @returns
+   */
+  static create(config) {
+    const transport = new RevolverTransport({
+      ...config
+    });
+    return (...args) => {
+      transport.overrides = args[0];
+      return transport;
+    };
+  }
+  constructor(config) {
+    this.#config = { ...config };
+    const rpcUrls = /* @__PURE__ */ new Map();
+    const cooldowns = /* @__PURE__ */ new Map();
+    for (const { provider, keys, cooldown } of config.providers) {
+      for (const key of keys) {
+        const url = (0, import_providers.getProviderUrl)(provider, config.network, key, "http");
+        if (url) {
+          rpcUrls.set(url, provider);
+          if (cooldown) {
+            cooldowns.set(url, cooldown);
+          }
+        }
+      }
+    }
+    this.#transports = Array.from(rpcUrls.entries()).map(
+      ([url, provider], i) => ({
+        provider,
+        transport: (0, import_viem.http)(url, {
+          retryCount: config.retryCount,
+          retryDelay: config.retryDelay,
+          timeout: config.timeout,
+          batch: false,
+          key: `${provider}-${i}`,
+          name: `${provider}-${i}`,
+          onFetchRequest: this.#config.onRequest ? (...args) => this.#config.onRequest?.(`${provider}-${i}`, ...args) : void 0,
+          onFetchResponse: this.#config.onResponse ? (...args) => this.#config.onResponse?.(`${provider}-${i}`, ...args) : void 0
+        }),
+        cooldown: cooldowns.get(url) ?? 0
+      })
+    );
+    if (this.#transports.length === 0) {
+      throw new NoAvailableTransportsError();
+    }
+  }
+  get value() {
+    return {
+      rotate: (reason) => this.rotate(reason),
+      currentTransportName: this.currentTransportName
+    };
+  }
+  request = async (r) => {
+    if (this.#transports.length === 1) {
+      return this.#transport({ ...this.overrides }).request(r);
+    }
+    do {
+      try {
+        const resp = await this.#transport({ ...this.overrides }).request(r);
+        return resp;
+      } catch (e) {
+        if (e instanceof import_viem.RpcError || e instanceof import_viem.HttpRequestError) {
+          await this.rotate(e);
+        } else {
+          throw e;
+        }
+      }
+    } while (this.#hasAvailableTransports);
+    throw new NoAvailableTransportsError();
+  };
+  get config() {
+    return {
+      key: "revolver",
+      name: "revolver",
+      type: "revolver",
+      request: this.request,
+      retryCount: this.#config.retryCount,
+      methods: void 0,
+      retryDelay: this.#config.retryDelay,
+      timeout: this.#config.timeout
+    };
+  }
+  /**
+   * Manually rotate the transport
+   * @param reason
+   * @returns true if rotation was successful
+   */
+  async rotate(reason) {
+    if (this.#transports.length === 1) {
+      return true;
+    }
+    this.#logger?.debug(
+      {
+        reason,
+        current: this.currentTransportName,
+        index: this.#index,
+        total: this.#transports.length
+      },
+      "rotating transport"
+    );
+    const oldTransportName = this.currentTransportName;
+    const now = Date.now();
+    this.#transports[this.#index].cooldown = now + (this.#config.cooldown ?? 6e4);
+    for (let i = 0; i < this.#transports.length - 1; i++) {
+      this.#index = (this.#index + 1) % this.#transports.length;
+      if (this.#transports[this.#index].cooldown < now) {
+        this.#logger?.info(
+          {
+            current: this.currentTransportName,
+            index: this.#index,
+            total: this.#transports.length
+          },
+          "switched to next transport"
+        );
+        await this.#config.onRotateSuccess?.(
+          oldTransportName,
+          this.currentTransportName,
+          reason
+        );
+        return true;
+      } else {
+        this.#logger?.warn(
+          {
+            current: this.currentTransportName,
+            index: this.#index,
+            total: this.#transports.length
+          },
+          "transport is still on cooldown"
+        );
+      }
+    }
+    await this.#config.onRotateFailed?.(reason);
+    return false;
+  }
+  get currentTransportName() {
+    return this.#transport({}).config.name;
+  }
+  get #logger() {
+    return this.#config.logger;
+  }
+  get #transport() {
+    return this.#transports[this.#index].transport;
+  }
+  get #hasAvailableTransports() {
+    const now = Date.now();
+    return this.#transports.some((t) => t.cooldown < now);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoAvailableTransportsError,
+  RevolverTransport
+});

package/dist/cjs/dev/index.js

@@ -21,11 +21,13 @@ __reExport(dev_exports, require("./calcLiquidatableLTs.js"), module.exports);
 __reExport(dev_exports, require("./claimFromFaucet.js"), module.exports);
 __reExport(dev_exports, require("./create2.js"), module.exports);
 __reExport(dev_exports, require("./createAnvilClient.js"), module.exports);
-__reExport(dev_exports, require("./createTransport.js"), module.exports);
 __reExport(dev_exports, require("./detectChain.js"), module.exports);
 __reExport(dev_exports, require("./EthCallSpy.js"), module.exports);
 __reExport(dev_exports, require("./ltUtils.js"), module.exports);
 __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
+__reExport(dev_exports, require("./providers.js"), module.exports);
+__reExport(dev_exports, require("./RevolverTransport.js"), module.exports);
+__reExport(dev_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./AccountOpener.js"),
@@ -34,9 +36,11 @@ __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
   ...require("./claimFromFaucet.js"),
   ...require("./create2.js"),
   ...require("./createAnvilClient.js"),
-  ...require("./createTransport.js"),
   ...require("./detectChain.js"),
   ...require("./EthCallSpy.js"),
   ...require("./ltUtils.js"),
-  ...require("./migrateFaucet.js")
+  ...require("./migrateFaucet.js"),
+  ...require("./providers.js"),
+  ...require("./RevolverTransport.js"),
+  ...require("./types.js")
 });

package/dist/cjs/dev/{createTransport.js → providers.js}

@@ -16,43 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var createTransport_exports = {};
-__export(createTransport_exports, {
-  createTransport: () => createTransport,
+var providers_exports = {};
+__export(providers_exports, {
   getAlchemyUrl: () => getAlchemyUrl,
   getDrpcUrl: () => getDrpcUrl,
   getProviderUrl: () => getProviderUrl
 });
-module.exports = __toCommonJS(createTransport_exports);
-var import_viem = require("viem");
+module.exports = __toCommonJS(providers_exports);
 var import_sdk = require("../sdk/index.js");
-function createTransport(config) {
-  const { rpcProviders = [], protocol, network, ...rest } = config;
-  const rpcUrls = /* @__PURE__ */ new Map();
-  for (const { provider, keys } of rpcProviders) {
-    for (const key of keys) {
-      const url = getProviderUrl(provider, network, key, protocol);
-      if (url) {
-        rpcUrls.set(url, provider);
-      }
-    }
-  }
-  const transports = Array.from(rpcUrls.entries()).map(
-    ([url, provider], index) => protocol === "http" ? (0, import_viem.http)(url, {
-      ...rest,
-      key: `${provider}-${index}`,
-      name: `${provider}-${index}`
-    }) : (0, import_viem.webSocket)(url, {
-      ...rest,
-      key: `${provider}-${index}`,
-      name: `${provider}-${index}`
-    })
-  );
-  if (transports.length === 0) {
-    throw new Error("no fitting rpc urls found");
-  }
-  return transports.length > 1 ? (0, import_viem.fallback)(transports) : transports[0];
-}
 function getProviderUrl(provider, network, apiKey, protocol) {
   switch (provider) {
     case "alchemy":
@@ -97,7 +68,6 @@ function getDrpcUrl(network, apiKey, protocol) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createTransport,
   getAlchemyUrl,
   getDrpcUrl,
   getProviderUrl

package/dist/cjs/dev/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/dev/RevolverTransport.js

@@ -0,0 +1,177 @@
+import {
+  BaseError,
+  HttpRequestError,
+  http,
+  RpcError
+} from "viem";
+import {
+  getProviderUrl
+} from "./providers.js";
+class NoAvailableTransportsError extends BaseError {
+  constructor() {
+    super("no available transports");
+  }
+}
+class RevolverTransport {
+  #transports;
+  #index = 0;
+  #config;
+  overrides;
+  /**
+   * Create a new RevolverTransport
+   * RevolverTransport usues several RPC providers and rotates between them when requests fail
+   * Failed transport goes into temporary cooldown, after which it can be tried again
+   * When all transports are on cooldown, the transport will throw a NoAvailableTransportsError
+   * @param config
+   * @returns
+   */
+  static create(config) {
+    const transport = new RevolverTransport({
+      ...config
+    });
+    return (...args) => {
+      transport.overrides = args[0];
+      return transport;
+    };
+  }
+  constructor(config) {
+    this.#config = { ...config };
+    const rpcUrls = /* @__PURE__ */ new Map();
+    const cooldowns = /* @__PURE__ */ new Map();
+    for (const { provider, keys, cooldown } of config.providers) {
+      for (const key of keys) {
+        const url = getProviderUrl(provider, config.network, key, "http");
+        if (url) {
+          rpcUrls.set(url, provider);
+          if (cooldown) {
+            cooldowns.set(url, cooldown);
+          }
+        }
+      }
+    }
+    this.#transports = Array.from(rpcUrls.entries()).map(
+      ([url, provider], i) => ({
+        provider,
+        transport: http(url, {
+          retryCount: config.retryCount,
+          retryDelay: config.retryDelay,
+          timeout: config.timeout,
+          batch: false,
+          key: `${provider}-${i}`,
+          name: `${provider}-${i}`,
+          onFetchRequest: this.#config.onRequest ? (...args) => this.#config.onRequest?.(`${provider}-${i}`, ...args) : void 0,
+          onFetchResponse: this.#config.onResponse ? (...args) => this.#config.onResponse?.(`${provider}-${i}`, ...args) : void 0
+        }),
+        cooldown: cooldowns.get(url) ?? 0
+      })
+    );
+    if (this.#transports.length === 0) {
+      throw new NoAvailableTransportsError();
+    }
+  }
+  get value() {
+    return {
+      rotate: (reason) => this.rotate(reason),
+      currentTransportName: this.currentTransportName
+    };
+  }
+  request = async (r) => {
+    if (this.#transports.length === 1) {
+      return this.#transport({ ...this.overrides }).request(r);
+    }
+    do {
+      try {
+        const resp = await this.#transport({ ...this.overrides }).request(r);
+        return resp;
+      } catch (e) {
+        if (e instanceof RpcError || e instanceof HttpRequestError) {
+          await this.rotate(e);
+        } else {
+          throw e;
+        }
+      }
+    } while (this.#hasAvailableTransports);
+    throw new NoAvailableTransportsError();
+  };
+  get config() {
+    return {
+      key: "revolver",
+      name: "revolver",
+      type: "revolver",
+      request: this.request,
+      retryCount: this.#config.retryCount,
+      methods: void 0,
+      retryDelay: this.#config.retryDelay,
+      timeout: this.#config.timeout
+    };
+  }
+  /**
+   * Manually rotate the transport
+   * @param reason
+   * @returns true if rotation was successful
+   */
+  async rotate(reason) {
+    if (this.#transports.length === 1) {
+      return true;
+    }
+    this.#logger?.debug(
+      {
+        reason,
+        current: this.currentTransportName,
+        index: this.#index,
+        total: this.#transports.length
+      },
+      "rotating transport"
+    );
+    const oldTransportName = this.currentTransportName;
+    const now = Date.now();
+    this.#transports[this.#index].cooldown = now + (this.#config.cooldown ?? 6e4);
+    for (let i = 0; i < this.#transports.length - 1; i++) {
+      this.#index = (this.#index + 1) % this.#transports.length;
+      if (this.#transports[this.#index].cooldown < now) {
+        this.#logger?.info(
+          {
+            current: this.currentTransportName,
+            index: this.#index,
+            total: this.#transports.length
+          },
+          "switched to next transport"
+        );
+        await this.#config.onRotateSuccess?.(
+          oldTransportName,
+          this.currentTransportName,
+          reason
+        );
+        return true;
+      } else {
+        this.#logger?.warn(
+          {
+            current: this.currentTransportName,
+            index: this.#index,
+            total: this.#transports.length
+          },
+          "transport is still on cooldown"
+        );
+      }
+    }
+    await this.#config.onRotateFailed?.(reason);
+    return false;
+  }
+  get currentTransportName() {
+    return this.#transport({}).config.name;
+  }
+  get #logger() {
+    return this.#config.logger;
+  }
+  get #transport() {
+    return this.#transports[this.#index].transport;
+  }
+  get #hasAvailableTransports() {
+    const now = Date.now();
+    return this.#transports.some((t) => t.cooldown < now);
+  }
+}
+export {
+  NoAvailableTransportsError,
+  RevolverTransport
+};

package/dist/esm/dev/index.js

@@ -4,8 +4,10 @@ export * from "./calcLiquidatableLTs.js";
 export * from "./claimFromFaucet.js";
 export * from "./create2.js";
 export * from "./createAnvilClient.js";
-export * from "./createTransport.js";
 export * from "./detectChain.js";
 export * from "./EthCallSpy.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
+export * from "./providers.js";
+export * from "./RevolverTransport.js";
+export * from "./types.js";

package/dist/esm/dev/{createTransport.js → providers.js}

@@ -1,32 +1,4 @@
-import { fallback, http, webSocket } from "viem";
 import { getChain } from "../sdk/index.js";
-function createTransport(config) {
-  const { rpcProviders = [], protocol, network, ...rest } = config;
-  const rpcUrls = /* @__PURE__ */ new Map();
-  for (const { provider, keys } of rpcProviders) {
-    for (const key of keys) {
-      const url = getProviderUrl(provider, network, key, protocol);
-      if (url) {
-        rpcUrls.set(url, provider);
-      }
-    }
-  }
-  const transports = Array.from(rpcUrls.entries()).map(
-    ([url, provider], index) => protocol === "http" ? http(url, {
-      ...rest,
-      key: `${provider}-${index}`,
-      name: `${provider}-${index}`
-    }) : webSocket(url, {
-      ...rest,
-      key: `${provider}-${index}`,
-      name: `${provider}-${index}`
-    })
-  );
-  if (transports.length === 0) {
-    throw new Error("no fitting rpc urls found");
-  }
-  return transports.length > 1 ? fallback(transports) : transports[0];
-}
 function getProviderUrl(provider, network, apiKey, protocol) {
   switch (provider) {
     case "alchemy":
@@ -70,7 +42,6 @@ function getDrpcUrl(network, apiKey, protocol) {
   return net ? `${protocol}s://lb.drpc.org/${net}/${apiKey}` : void 0;
 }
 export {
-  createTransport,
   getAlchemyUrl,
   getDrpcUrl,
   getProviderUrl

package/dist/types/dev/EthCallSpy.d.ts

@@ -1,6 +1,6 @@
 import type { EIP1193Parameters, Hex, HttpTransportConfig, PublicRpcSchema, RequiredBy } from "viem";
-import type { RpcResponse } from "viem/_types/types/rpc.js";
 import type { ILogger } from "../sdk/index.js";
+import type { RpcResponse } from "./types.js";
 export type EthCallMethod = Extract<PublicRpcSchema[number], {
     Method: "eth_call";
 }>;

package/dist/types/dev/RevolverTransport.d.ts

@@ -0,0 +1,77 @@
+import { BaseError, type ClientConfig, type EIP1193RequestFn, type Transport, type TransportConfig } from "viem";
+import type { HttpRpcClientOptions } from "viem/utils";
+import type { ILogger, NetworkType } from "../sdk/index.js";
+import { type ProviderConfig } from "./providers.js";
+type OnRequestFn = (providerName: string, ...args: Parameters<Required<HttpRpcClientOptions>["onRequest"]>) => ReturnType<Required<HttpRpcClientOptions>["onRequest"]>;
+type OnResponseFn = (providerName: string, ...args: Parameters<Required<HttpRpcClientOptions>["onResponse"]>) => ReturnType<Required<HttpRpcClientOptions>["onResponse"]>;
+export interface RevolverTransportConfig {
+    network: NetworkType;
+    providers: ProviderConfig[];
+    logger?: ILogger;
+    key?: TransportConfig["key"] | undefined;
+    name?: TransportConfig["name"] | undefined;
+    pollingInterval?: ClientConfig["pollingInterval"] | undefined;
+    retryCount?: TransportConfig["retryCount"] | undefined;
+    retryDelay?: TransportConfig["retryDelay"] | undefined;
+    timeout?: TransportConfig["timeout"] | undefined;
+    /**
+     * Spying function that also returns provider name in additional to the request
+     */
+    onRequest?: OnRequestFn;
+    /**
+     * Spying function that also returns provider name in additional to the response
+     */
+    onResponse?: OnResponseFn;
+    /**
+     * Callback that is called when the transport is rotated
+     */
+    onRotateSuccess?: (oldTransportName: string, newTransportName: string, reason?: BaseError) => void | Promise<void>;
+    /**
+     * Callback that is called when the transport cannot be rotated
+     */
+    onRotateFailed?: (reason?: BaseError) => void | Promise<void>;
+    /**
+     * How long, in milliseconds, to wait before try this transport again
+     */
+    cooldown?: number | undefined;
+}
+export declare class NoAvailableTransportsError extends BaseError {
+    constructor();
+}
+export interface RevolverTransportValue {
+    /**
+     * Manually rotate the transport
+     * @param reason
+     * @returns true if rotation was successful
+     */
+    rotate: (reason?: BaseError) => Promise<boolean>;
+    /**
+     * The name of the current transport
+     */
+    currentTransportName: string;
+}
+export declare class RevolverTransport implements ReturnType<Transport<"revolver", RevolverTransportValue>> {
+    #private;
+    private overrides?;
+    /**
+     * Create a new RevolverTransport
+     * RevolverTransport usues several RPC providers and rotates between them when requests fail
+     * Failed transport goes into temporary cooldown, after which it can be tried again
+     * When all transports are on cooldown, the transport will throw a NoAvailableTransportsError
+     * @param config
+     * @returns
+     */
+    static create(config: RevolverTransportConfig): Transport<"revolver">;
+    constructor(config: RevolverTransportConfig);
+    get value(): RevolverTransportValue;
+    request: EIP1193RequestFn;
+    get config(): TransportConfig<"revolver">;
+    /**
+     * Manually rotate the transport
+     * @param reason
+     * @returns true if rotation was successful
+     */
+    rotate(reason?: BaseError): Promise<boolean>;
+    get currentTransportName(): string;
+}
+export {};

package/dist/types/dev/index.d.ts

@@ -4,8 +4,10 @@ export * from "./calcLiquidatableLTs.js";
 export * from "./claimFromFaucet.js";
 export * from "./create2.js";
 export * from "./createAnvilClient.js";
-export * from "./createTransport.js";
 export * from "./detectChain.js";
 export * from "./EthCallSpy.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
+export * from "./providers.js";
+export * from "./RevolverTransport.js";
+export * from "./types.js";

package/dist/types/dev/{createTransport.d.ts → providers.d.ts}

@@ -1,9 +1,10 @@
-import type { HttpTransportConfig, Transport, WebSocketTransportConfig } from "viem";
+import type { HttpTransportConfig, WebSocketTransportConfig } from "viem";
 import type { NetworkType } from "../sdk/index.js";
 export type RpcProvider = "alchemy" | "drpc" | "custom";
 export interface ProviderConfig {
     provider: RpcProvider;
     keys: string[];
+    cooldown?: number;
 }
 export interface CreateTransportURLOptions {
     /**
@@ -19,13 +20,6 @@ export type CreateWSTransportConfig = {
     protocol: "ws";
 } & WebSocketTransportConfig & CreateTransportURLOptions;
 export type CreateTransportConfig = CreateHTTPTransportConfig | CreateWSTransportConfig;
-/**
- * Helper method to create viem Transport using API keys of well-known RPC providers and explicit fallback URLs
- * Currently only supports Alchemy
- * @param config
- * @returns
- */
-export declare function createTransport(config: CreateTransportConfig): Transport;
 export declare function getProviderUrl(provider: RpcProvider, network: NetworkType, apiKey: string, protocol: "http" | "ws"): string | undefined;
 export declare function getAlchemyUrl(network: NetworkType, apiKey: string, protocol: "http" | "ws"): string | undefined;
 export declare function getDrpcUrl(network: NetworkType, apiKey: string, protocol: "http" | "ws"): string | undefined;

package/dist/types/dev/types.d.ts

@@ -0,0 +1,14 @@
+export type RpcSuccessResult<result> = {
+    method?: undefined;
+    result: result;
+    error?: undefined;
+};
+export type RpcErrorResult<error> = {
+    method?: undefined;
+    result?: undefined;
+    error: error;
+};
+export type RpcResponse<result = any, error = any> = {
+    jsonrpc: `${number}`;
+    id: number;
+} & (RpcSuccessResult<result> | RpcErrorResult<error>);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "9.0.3",
+  "version": "9.1.0",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",

package/dist/types/sdk/chain/detectNetwork.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/sdk/market/pricefeeds/updates/RedstoneUpdater.test.d.ts

@@ -1 +0,0 @@
-export {};