fizen-evm-networks 1.0.0

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,163 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+class FizenEvmNetworks {
+    constructor(ids) {
+        this._chains = [];
+        this.formatData = (url, data) => {
+            var _a, _b, _c;
+            let height = (_b = (_a = data === null || data === void 0 ? void 0 : data.result) === null || _a === void 0 ? void 0 : _a.number) !== null && _b !== void 0 ? _b : null;
+            let latency = (_c = data === null || data === void 0 ? void 0 : data.latency) !== null && _c !== void 0 ? _c : null;
+            if (height) {
+                const hexString = height.toString(16);
+                height = parseInt(hexString, 16);
+            }
+            else {
+                latency = null;
+            }
+            return { url, height, latency };
+        };
+        this._whiteListChainIds = ids;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._chains = yield this._fetchChains();
+            this._internalFetchChains();
+        });
+    }
+    setWhiteListchainIds(ids) {
+        this._whiteListChainIds = ids;
+    }
+    _internalFetchChains() {
+        for (let chain of this._chains) {
+            this._fetchRPCData(chain.chainId, chain.rpc);
+        }
+    }
+    _fetchChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chains = yield (0, utils_1.fetcher)("https://chainid.network/chains.json");
+            const chainTvls = yield (0, utils_1.fetcher)("https://api.llama.fi/chains");
+            const sortedChains = chains
+                .filter((c) => c.name !== "420coin") // same chainId as ronin
+                .filter((c) => this._whiteListChainIds.includes(c.chainId))
+                .map((chain) => (0, utils_1.populateChain)(chain, chainTvls))
+                .sort((a, b) => {
+                var _a, _b;
+                return ((_a = b.tvl) !== null && _a !== void 0 ? _a : 0) - ((_b = a.tvl) !== null && _b !== void 0 ? _b : 0);
+            });
+            return sortedChains;
+        });
+    }
+    _fetchRPCData(chainId, urls) {
+        const queries = urls.map((url) => url.includes("wss://")
+            ? this._socketQuery(chainId, url)
+            : this._httpQuery(chainId, url));
+        return queries;
+    }
+    _socketQuery(chainId, url) { }
+    _httpQuery(chainId, url) {
+        setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._fetchChain(url);
+            const dataFormated = this.formatData(url, data);
+            const chainFound = this._chains.find((chain) => chain.chainId === chainId);
+            if (chainFound) {
+                const found = chainFound.rpcsScore.find((rpc) => rpc.url === url);
+                if (found) {
+                    found.latency = dataFormated.latency;
+                    found.height = dataFormated.height;
+                }
+            }
+        }), 5000);
+    }
+    _fetchChain(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (url.includes("API_KEY"))
+                return null;
+            try {
+                let API = axios_1.default.create({
+                    url,
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                });
+                API.interceptors.request.use(function (request) {
+                    request.requestStart = Date.now();
+                    return request;
+                });
+                API.interceptors.response.use(function (response) {
+                    response.latency =
+                        Date.now() - response.config.requestStart;
+                    return response;
+                }, function (error) {
+                    console.log(error);
+                    if (error.response) {
+                        error.response.latency = null;
+                    }
+                    return Promise.reject(error);
+                });
+                const rpcBody = JSON.stringify({
+                    jsonrpc: "2.0",
+                    method: "eth_getBlockByNumber",
+                    params: ["latest", false],
+                    id: 1,
+                });
+                const res = yield API.post(url, rpcBody);
+                let { data, latency } = res;
+                return Object.assign(Object.assign({}, data), { latency });
+            }
+            catch (error) {
+                return null;
+            }
+        });
+    }
+    getChains() {
+        return this._chains;
+    }
+    getLowestLatencyChain(chainId) {
+        const chain = this._chains.find((c) => c.chainId === chainId);
+        if (!chain)
+            return null;
+        const rpcsScore = chain.rpcsScore
+            .sort((a, b) => {
+            return a.latency - b.latency;
+        })
+            .filter((rpc) => rpc.latency !== null);
+        return rpcsScore[0];
+    }
+}
+// (async () => {
+//   const a = new FizenEvmNetworks([80001]);
+//   // const a = new FizenEvmNetworks([1, 137, 80001, 56, 97]);
+//   await a.init();
+//   let chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+//   // Sleep for 5 seconds
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+//   chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+//   chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+//   chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+//   chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+//   chains = a.getLowestLatencyChain(80001);
+//   console.log(chains);
+// })();

package/lib/lib/pubsub.d.ts

@@ -0,0 +1,24 @@
+export default class PubSub {
+    private events;
+    constructor();
+    /**
+     * Either create a new event instance for passed `event` name
+     * or push a new callback into the existing collection
+     *
+     * @param {string} event
+     * @param {function} callback
+     * @returns {number} A count of callbacks for this event
+     * @memberof PubSub
+     */
+    subscribe(event: string, callback: Function): any;
+    /**
+     * If the passed event has callbacks attached to it, loop through each one
+     * and call it
+     *
+     * @param {string} event
+     * @param {object} [data={}]
+     * @returns {array} The callbacks for this event, or an empty array if no event exits
+     * @memberof PubSub
+     */
+    publish(event: string, data?: {}): any;
+}

package/lib/lib/pubsub.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PubSub {
+    constructor() {
+        this.events = {};
+    }
+    /**
+     * Either create a new event instance for passed `event` name
+     * or push a new callback into the existing collection
+     *
+     * @param {string} event
+     * @param {function} callback
+     * @returns {number} A count of callbacks for this event
+     * @memberof PubSub
+     */
+    subscribe(event, callback) {
+        let self = this;
+        // If there's not already an event with this name set in our collection
+        // go ahead and create a new one and set it with an empty array, so we don't
+        // have to type check it later down-the-line
+        if (!self.events.hasOwnProperty(event)) {
+            self.events[event] = [];
+        }
+        // We know we've got an array for this event, so push our callback in there with no fuss
+        return self.events[event].push(callback);
+    }
+    /**
+     * If the passed event has callbacks attached to it, loop through each one
+     * and call it
+     *
+     * @param {string} event
+     * @param {object} [data={}]
+     * @returns {array} The callbacks for this event, or an empty array if no event exits
+     * @memberof PubSub
+     */
+    publish(event, data = {}) {
+        let self = this;
+        // There's no event to publish to, so bail out
+        if (!self.events.hasOwnProperty(event)) {
+            return [];
+        }
+        // Get each subscription and call its callback with the passed data
+        return self.events[event].map((callback) => callback(data));
+    }
+}
+exports.default = PubSub;

package/lib/store/actions.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    addItem(context: any, payload: any): void;
+    clearItem(context: any, payload: any): void;
+};
+export default _default;

package/lib/store/actions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    addItem(context, payload) {
+        context.commit("addItem", payload);
+    },
+    clearItem(context, payload) {
+        context.commit("clearItem", payload);
+    },
+};

package/lib/store/index.d.ts

@@ -0,0 +1,3 @@
+import Store from "./store.js";
+declare const _default: Store;
+export default _default;

package/lib/store/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actions_js_1 = __importDefault(require("./actions.js"));
+const mutations_js_1 = __importDefault(require("./mutations.js"));
+const state_js_1 = __importDefault(require("./state.js"));
+const store_js_1 = __importDefault(require("./store.js"));
+exports.default = new store_js_1.default({
+    actions: actions_js_1.default,
+    mutations: mutations_js_1.default,
+    state: state_js_1.default,
+});

package/lib/store/mutations.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    addItem(state: any, payload: any): any;
+    clearItem(state: any, payload: any): any;
+};
+export default _default;

package/lib/store/mutations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    addItem(state, payload) {
+        state.items.push(payload);
+        return state;
+    },
+    clearItem(state, payload) {
+        state.items.splice(payload.index, 1);
+        return state;
+    },
+};

package/lib/store/state.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    items: string[];
+};
+export default _default;

package/lib/store/state.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    items: ["I made this", "Another thing"],
+};

package/lib/store/store.d.ts

@@ -0,0 +1,35 @@
+export default class Store {
+    private actions;
+    private mutations;
+    private state;
+    private status;
+    private events;
+    constructor(params: {
+        state: any;
+        actions: any;
+        mutations: any;
+        plugins?: any;
+        middleware?: any;
+        pubsub?: any;
+    });
+    /**
+     * A dispatcher for actions that looks in the actions
+     * collection and runs the action if it can find it
+     *
+     * @param {string} actionKey
+     * @param {mixed} payload
+     * @returns {boolean}
+     * @memberof Store
+     */
+    dispatch(actionKey: string, payload: any): boolean;
+    /**
+     * Look for a mutation and modify the state object
+     * if that mutation exists by calling it
+     *
+     * @param {string} mutationKey
+     * @param {mixed} payload
+     * @returns {boolean}
+     * @memberof Store
+     */
+    commit(mutationKey: string, payload: any): boolean;
+}

package/lib/store/store.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pubsub_js_1 = __importDefault(require("../lib/pubsub.js"));
+class Store {
+    constructor(params) {
+        this.status = "resting";
+        this.events = new pubsub_js_1.default();
+        let self = this;
+        // Add some default objects to hold our actions, mutations and state
+        self.actions = {};
+        self.mutations = {};
+        self.state = {};
+        // A status enum to set during actions and mutations
+        self.status = "resting";
+        // Attach our PubSub module as an `events` element
+        self.events = new pubsub_js_1.default();
+        // Look in the passed params object for actions and mutations
+        // that might have been passed in
+        if (params.hasOwnProperty("actions")) {
+            self.actions = params.actions;
+        }
+        if (params.hasOwnProperty("mutations")) {
+            self.mutations = params.mutations;
+        }
+        // Set our state to be a Proxy. We are setting the default state by
+        // checking the params and defaulting to an empty object if no default
+        // state is passed in
+        self.state = new Proxy(params.state || {}, {
+            set: function (state, key, value) {
+                // Set the value as we would normally
+                state[key] = value;
+                // Trace out to the console. This will be grouped by the related action
+                console.log(`stateChange: ${key}: ${value}`);
+                // Publish the change event for the components that are listening
+                self.events.publish("stateChange", self.state);
+                // Give the user a little telling off if they set a value directly
+                if (self.status !== "mutation") {
+                    console.warn(`You should use a mutation to set ${key}`);
+                }
+                // Reset the status ready for the next operation
+                self.status = "resting";
+                return true;
+            },
+        });
+    }
+    /**
+     * A dispatcher for actions that looks in the actions
+     * collection and runs the action if it can find it
+     *
+     * @param {string} actionKey
+     * @param {mixed} payload
+     * @returns {boolean}
+     * @memberof Store
+     */
+    dispatch(actionKey, payload) {
+        let self = this;
+        // Run a quick check to see if the action actually exists
+        // before we try to run it
+        if (typeof self.actions[actionKey] !== "function") {
+            console.error(`Action "${actionKey} doesn't exist.`);
+            return false;
+        }
+        // Create a console group which will contain the logs from our Proxy etc
+        console.groupCollapsed(`ACTION: ${actionKey}`);
+        // Let anything that's watching the status know that we're dispatching an action
+        self.status = "action";
+        // Actually call the action and pass it the Store context and whatever payload was passed
+        self.actions[actionKey](self, payload);
+        // Close our console group to keep things nice and neat
+        console.groupEnd();
+        return true;
+    }
+    /**
+     * Look for a mutation and modify the state object
+     * if that mutation exists by calling it
+     *
+     * @param {string} mutationKey
+     * @param {mixed} payload
+     * @returns {boolean}
+     * @memberof Store
+     */
+    commit(mutationKey, payload) {
+        let self = this;
+        // Run a quick check to see if this mutation actually exists
+        // before trying to run it
+        if (typeof self.mutations[mutationKey] !== "function") {
+            console.log(`Mutation "${mutationKey}" doesn't exist`);
+            return false;
+        }
+        // Let anything that's watching the status know that we're mutating state
+        self.status = "mutation";
+        // Get a new version of the state by running the mutation and storing the result of it
+        let newState = self.mutations[mutationKey](self.state, payload);
+        // Merge the old and new together to create a new state and set it
+        self.state = Object.assign(self.state, newState);
+        return true;
+    }
+}
+exports.default = Store;

package/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { RequestInfo, RequestInit } from "node-fetch";
+export declare const fetcher: (args_0: RequestInfo, args_1?: RequestInit | undefined) => Promise<any>;
+export declare function populateChain(chain: any, chainTvls: any[]): any;

package/lib/utils/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateChain = exports.fetcher = void 0;
+const rpcs_json_1 = __importDefault(require("../constants/rpcs.json"));
+const chainIds_1 = __importDefault(require("../constants/chainIds"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const fetcher = (...args) => (0, node_fetch_1.default)(...args).then((res) => res.json());
+exports.fetcher = fetcher;
+function removeEndingSlash(rpc) {
+    return rpc.endsWith("/") ? rpc.substr(0, rpc.length - 1) : rpc;
+}
+function populateChain(chain, chainTvls) {
+    var _a;
+    const extraRpcs = (_a = rpcs_json_1.default[chain.chainId]) === null || _a === void 0 ? void 0 : _a.rpcs;
+    if (extraRpcs !== undefined) {
+        const rpcs = new Set(chain.rpc
+            .map(removeEndingSlash)
+            .filter((rpc) => !rpc.includes("${INFURA_API_KEY}")));
+        extraRpcs.forEach((rpc) => rpcs.add(removeEndingSlash(rpc)));
+        chain.rpc = Array.from(rpcs);
+        chain.rpcsScore = chain.rpc.map((url) => ({
+            url: url,
+            height: null,
+            latency: null,
+        }));
+    }
+    const chainSlug = chainIds_1.default[chain.chainId];
+    if (chainSlug !== undefined) {
+        const defiChain = chainTvls.find((c) => c.name.toLowerCase() === chainSlug);
+        return defiChain === undefined
+            ? chain
+            : Object.assign(Object.assign({}, chain), { tvl: defiChain.tvl, chainSlug });
+    }
+    return chain;
+}
+exports.populateChain = populateChain;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "fizen-evm-networks",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sotanext-team/fizen-evm-networks.git"
+  },
+  "devDependencies": {
+    "@types/node": "^18.7.1",
+    "@types/node-fetch": "^2.6.2",
+    "typescript": "^4.7.4"
+  },
+  "author": "Nora",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/sotanext-team/fizen-evm-networks/issues"
+  },
+  "homepage": "https://github.com/sotanext-team/fizen-evm-networks#readme",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "axios": "^0.27.2",
+    "node-fetch": "^2.5.12",
+    "ts-node": "^10.9.1"
+  }
+}