@witnet/sdk 1.0.0-beta.0

package/dist/src/lib/rpc/nodes.js

@@ -0,0 +1,293 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcNodeFarm = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils = __importStar(require("../utils"));
+const types_1 = require("../crypto/types");
+const provider_1 = require("./provider");
+const types_2 = require("./types");
+function isPrivateURL(url) {
+    const [, host,] = utils.parseURL(url);
+    return utils.ipIsPrivateOrLocalhost(host.split(':')[0]);
+}
+class JsonRpcNodeFarm extends provider_1.JsonRpcProvider {
+    constructor(url) {
+        super(url || process.env.WITNET_TOOLKIT_FARM_NODES || "http://127.0.0.1:21339");
+        this.endpoints.forEach(url => {
+            if (!isPrivateURL(url)) {
+                throw Error(`Witnet.JsonRpcNodeFarm: only local host or private IPs can be provided: ${url}`);
+            }
+        });
+    }
+    async batchApiPkhMethod(method, params) {
+        return this.addresses()
+            .then(async (addresses) => {
+            const promises = Object.entries(addresses).map(async ([url, pkh]) => [
+                url, [
+                    pkh,
+                    pkh instanceof Error ? undefined : await this.callApiMethod(url, method, { pkh, ...params })
+                ],
+            ]);
+            return Promise.all(promises);
+        })
+            .then(entries => Object.fromEntries(entries.map(([url, [pkh, value]]) => {
+            if (value && value instanceof Error) {
+                if (value?.error?.message) {
+                    value = new Error(value?.error?.message);
+                    delete value.stack;
+                }
+            }
+            return [url, [pkh, value || ""]];
+        })));
+    }
+    async batchApiPkhMethodNoPkh(method, ...params) {
+        return this.addresses()
+            .then(async (addresses) => {
+            const promises = Object.entries(addresses).map(async ([url, pkh]) => [
+                url, [
+                    pkh,
+                    pkh instanceof Error ? undefined : await this.callApiMethod(url, method, params)
+                ],
+            ]);
+            return Promise.all(promises);
+        })
+            .then(entries => Object.fromEntries(entries.map(([url, [pkh, value]]) => {
+            if (value && value instanceof Error) {
+                if (value?.error?.message) {
+                    value = new Error(value?.error?.message);
+                    delete value.stack;
+                }
+            }
+            return [url, [pkh, value || ""]];
+        })));
+    }
+    async batchApiMethod(method, params) {
+        const promises = this.endpoints.map(async (url) => axios_1.default
+            .post(url, {
+            jsonrpc: '2.0',
+            id: +new Date(),
+            method,
+            params,
+        }, {
+            headers: this._headers,
+        }).then((response) => {
+            if (response?.error || response?.data?.error) {
+                return [url, new provider_1.JsonRpcProviderError(method, params, response?.error || response?.data?.error)];
+            }
+            else {
+                return [url, response?.data?.result];
+            }
+        })
+            .catch((exception) => {
+            const error = new Error(exception?.message || exception?.error || exception);
+            delete error.stack;
+            return [url, error];
+        }));
+        return Promise.all(promises).then(values => Object.fromEntries(values));
+    }
+    async callApiMethod(url, method, params) {
+        return (axios_1.default
+            .post(url, {
+            jsonrpc: '2.0',
+            id: +new Date(),
+            method,
+            params,
+        }, {
+            headers: this._headers,
+        }).then((response) => {
+            if (response?.error || response?.data?.error) {
+                const error = new provider_1.JsonRpcProviderError(method, params, response?.error || response?.data?.error);
+                delete error?.stack;
+                return error;
+            }
+            else {
+                return response?.data?.result;
+            }
+        })
+            .catch((exception) => {
+            const error = new Error(exception?.message || exception?.error || exception);
+            delete error?.stack;
+            return error;
+        }));
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    async addresses() {
+        return this.batchApiMethod(types_2.Methods.GetPkh);
+    }
+    async balances() {
+        return this.batchApiPkhMethod(types_2.Methods.GetBalance2);
+    }
+    async masterKeys() {
+        return this.batchApiPkhMethodNoPkh(types_2.Methods.MasterKeyExport);
+    }
+    async publicKeys() {
+        return this.batchApiPkhMethodNoPkh(types_2.Methods.GetPublicKey)
+            .then((results) => Object.fromEntries(Object.entries(results).map(([url, [pkh, raw]]) => {
+            if (raw && raw instanceof Error) {
+                if (raw?.error?.message) {
+                    raw = new Error(raw?.error?.message);
+                    delete raw.stack;
+                }
+                return [url, [pkh, raw]];
+            }
+            else {
+                return [url, [pkh, raw ? types_1.PublicKey.fromUint8Array(raw) : undefined]];
+            }
+        })));
+    }
+    async peers() {
+        return this.batchApiMethod(types_2.Methods.Peers)
+            .then((results) => {
+            let peers = [];
+            Object.values(results).forEach((morePeers) => {
+                if (!(morePeers instanceof Error)) {
+                    morePeers.forEach(peer => {
+                        if (!peers.includes(peer)) {
+                            peers.push(peer);
+                        }
+                    });
+                }
+            });
+            return peers;
+        });
+    }
+    async stats() {
+        return this.batchApiMethod(types_2.Methods.NodeStats);
+    }
+    async syncStatus() {
+        return this.batchApiMethod(types_2.Methods.SyncStatus);
+    }
+    async withdrawers(limit, offset) {
+        return this.addresses()
+            .then(async (addresses) => {
+            const promises = Object.entries(addresses).map(async ([url, validator]) => [
+                url,
+                validator instanceof Error
+                    ? undefined
+                    : await this.callApiMethod(url, types_2.Methods.QueryStakes, {
+                        filter: { validator },
+                        params: {
+                            limit, offset,
+                            since: 0,
+                        }
+                    }),
+            ]);
+            return Promise.all(promises);
+        })
+            .then(entries => Object.fromEntries(entries.map(([url, stakes]) => {
+            if (stakes && stakes instanceof Error) {
+                if (stakes?.error?.message) {
+                    stakes = new Error(stakes?.error?.message);
+                    delete stakes.stack;
+                }
+                return [url,];
+            }
+            else {
+            }
+            return [url, stakes];
+        })))
+            .then((results) => {
+            const max = (a, b) => a > b ? a : b;
+            const withdrawers = {};
+            Object.values(results).forEach(moreEntries => {
+                if (moreEntries && !(moreEntries instanceof Error)) {
+                    moreEntries.forEach(entry => {
+                        if (withdrawers[entry.key.withdrawer]) {
+                            withdrawers[entry.key.withdrawer][0] += entry.value.coins;
+                            withdrawers[entry.key.withdrawer][1] = max(entry.value.nonce, withdrawers[entry.key.withdrawer][1]);
+                            withdrawers[entry.key.withdrawer][2] += 1;
+                        }
+                        else {
+                            withdrawers[entry.key.withdrawer] = [
+                                entry.value.coins,
+                                entry.value.nonce,
+                                1,
+                            ];
+                        }
+                    });
+                }
+            });
+            return Object.fromEntries(Object.entries(withdrawers)
+                .sort(([, [a, ,]], [, [b, ,]]) => {
+                if (a > b)
+                    return 1;
+                else if (a < b)
+                    return -1;
+                else
+                    return 0;
+            }));
+        });
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    async addPeers(peers) {
+        return this.batchApiMethod(types_2.Methods.AddPeers, peers);
+    }
+    async authorizeStakes(withdrawer) {
+        const msg = types_1.PublicKeyHash.fromBech32(withdrawer).toBytes32();
+        return this.batchApiPkhMethodNoPkh(types_2.Methods.AuthorizeStake, withdrawer)
+            .then((records) => Object.fromEntries(Object.entries(records).map(([url, [pkh, authorization]]) => {
+            if (authorization && authorization instanceof Error) {
+                if (authorization?.error?.message) {
+                    authorization = new Error(authorization?.error?.message);
+                    delete authorization.stack;
+                }
+                return [url, [pkh, authorization]];
+            }
+            else if (authorization) {
+                const signature = types_1.RecoverableSignature.fromKeyedSignature(authorization.signature, msg);
+                const authcode = signature.pubKey.hash().toHexString() + signature.toHexString();
+                return [url, [pkh, authcode]];
+            }
+            else {
+                return [url, [pkh, undefined]];
+            }
+        })));
+    }
+    async clearPeers() {
+        return this.batchApiMethod(types_2.Methods.ClearPeers);
+    }
+    async initializePeers() {
+        return this.batchApiMethod(types_2.Methods.InitializePeers);
+    }
+    async rewind(epoch) {
+        return this.batchApiMethod(types_2.Methods.Rewind, [epoch,]);
+    }
+}
+exports.JsonRpcNodeFarm = JsonRpcNodeFarm;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../../../src/lib/rpc/nodes.ts"],"names":[],"mappings":"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","sourcesContent":["import { default as axios } from \"axios\"\r\nimport * as utils from \"../utils\"\r\n\r\nimport {\r\n    PublicKey, \r\n    PublicKeyHash, \r\n    PublicKeyHashString, \r\n    RecoverableSignature \r\n} from \"../crypto/types\"\r\n\r\nimport { IJsonRpcProvider, JsonRpcProvider, JsonRpcProviderError } from \"./provider\"\r\n\r\nimport { \r\n    Balance2, \r\n    Methods, \r\n    NodeStats, \r\n    PeerAddr, \r\n    StakeAuthorization, \r\n    StakeEntry,\r\n    SyncStatus,\r\n} from \"./types\"\r\n\r\nimport { \r\n    Epoch, \r\n    HexString, \r\n    Nonce\r\n} from \"../types\"\r\n\r\nexport interface IJsonRpcNodeFarm extends IJsonRpcProvider {\r\n    addresses(): Promise<Record<string, PublicKeyHashString>>\r\n    balances(): Promise<Record<string, [PublicKeyHashString, Balance2]>>\r\n    masterKeys(): Promise<Record<string, [PublicKeyHashString, string]>>\r\n    publicKeys(): Promise<Record<string, [PublicKeyHashString, PublicKey]>>\r\n    syncStatus(): Promise<Record<string, SyncStatus>>\r\n\r\n    peers(validator?: PublicKeyHashString): Promise<Array<PeerAddr>>;\r\n    stats(): Promise<Record<string, NodeStats>>;\r\n    withdrawers(): Promise<Record<PublicKeyHashString, [BigInt, Nonce, number]>>;\r\n\r\n    addPeers(peers: Array<string>): Promise<Record<string, Boolean>>;\r\n    authorizeStakes(withdrawer: PublicKeyHashString): Promise<Record<string, [PublicKeyHashString, HexString]>>;\r\n    clearPeers(): Promise<Record<string, Boolean>>;\r\n    initializePeers(): Promise<Record<string, Boolean>>;\r\n    rewind(epoch: Epoch): Promise<Record<string, Boolean>>;\r\n}\r\n\r\nfunction isPrivateURL(url: string): boolean {\r\n    const [, host, ] = utils.parseURL(url)\r\n    return utils.ipIsPrivateOrLocalhost(host.split(':')[0])\r\n}\r\n\r\nexport class JsonRpcNodeFarm extends JsonRpcProvider implements IJsonRpcNodeFarm {\r\n    constructor(url?: string) {\r\n        super(url || process.env.WITNET_TOOLKIT_FARM_NODES || \"http://127.0.0.1:21339\")\r\n        this.endpoints.forEach(url => {\r\n            if (!isPrivateURL(url)) {\r\n                throw Error(`Witnet.JsonRpcNodeFarm: only local host or private IPs can be provided: ${url}`)\r\n            }\r\n        })\r\n    }\r\n\r\n    protected async batchApiPkhMethod<T>(method: string, params?: any): Promise<Record<string, [PublicKeyHashString, T]>> {\r\n        return this.addresses()\r\n            .then(async (addresses: Record<string, Error | string>) => {\r\n                const promises = Object.entries(addresses).map(async ([url, pkh]) => [\r\n                    url, [\r\n                        pkh,\r\n                        pkh instanceof Error ? undefined : await this.callApiMethod<T>(url, method, { pkh, ...params })\r\n                    ],\r\n                ]);\r\n                return Promise.all(promises)\r\n            })\r\n            .then(entries => Object.fromEntries(entries.map(([url, [pkh, value]]) => {\r\n                if (value && value instanceof Error) {\r\n                    if ((value as JsonRpcProviderError)?.error?.message) {\r\n                        value = new Error((value as JsonRpcProviderError)?.error?.message)\r\n                        delete value.stack\r\n                    }\r\n                }\r\n                return [url, [pkh, value || \"\"]]\r\n            })))\r\n    }\r\n\r\n    protected async batchApiPkhMethodNoPkh<T>(method: string, ...params: Array<any>): Promise<Record<string, [PublicKeyHashString, T]>> {\r\n        return this.addresses()\r\n            .then(async (addresses: Record<string, Error | string>) => {\r\n                const promises = Object.entries(addresses).map(async ([url, pkh]) => [\r\n                    url, [\r\n                        pkh,\r\n                        pkh instanceof Error ? undefined : await this.callApiMethod<T>(url, method, params)\r\n                    ],\r\n                ]);\r\n                return Promise.all(promises)\r\n            })\r\n            .then(entries => Object.fromEntries(entries.map(([url, [pkh, value]]) => {\r\n                if (value && value instanceof Error) {\r\n                    if ((value as JsonRpcProviderError)?.error?.message) {\r\n                        value = new Error((value as JsonRpcProviderError)?.error?.message)\r\n                        delete value.stack\r\n                    }\r\n                }\r\n                return [url, [pkh, value || \"\"]]            \r\n            })))\r\n    }\r\n\r\n    protected async batchApiMethod<T>(method: string, params?: Array<any> | any ): Promise<Record<string, T>> {\r\n        const promises = this.endpoints.map(async (url) => \r\n            axios\r\n                .post(\r\n                    url, {\r\n                        jsonrpc: '2.0',\r\n                        id: + new Date(),\r\n                        method,\r\n                        params,\r\n                    }, {\r\n                        headers: this._headers,\r\n                    }\r\n                ).then((response: any) => {\r\n                    if (response?.error || response?.data?.error) {\r\n                        return [url, new JsonRpcProviderError(method, params, response?.error || response?.data?.error)]\r\n                    } else {\r\n                        return [url, response?.data?.result as T]\r\n                    }\r\n                })\r\n                .catch((exception: any) => {\r\n                    const error = new Error(exception?.message || exception?.error || exception)\r\n                    delete error.stack\r\n                    return [url, error]\r\n                })\r\n        )\r\n        return Promise.all(promises).then(values => Object.fromEntries(values))\r\n    }\r\n\r\n    protected async callApiMethod<T>(url: string, method: string, params?: Array<any> | any ): Promise<Error | any> {\r\n        return (\r\n            axios\r\n                .post(\r\n                    url, {\r\n                        jsonrpc: '2.0',\r\n                        id: + new Date(),\r\n                        method,\r\n                        params,\r\n                    }, {\r\n                        headers: this._headers,\r\n                    }\r\n                ).then((response: any) => {\r\n                    if (response?.error || response?.data?.error) {\r\n                        const error = new JsonRpcProviderError(method, params, response?.error || response?.data?.error)\r\n                        delete error?.stack\r\n                        return error\r\n                    } else {\r\n                        return response?.data?.result as T\r\n                    }\r\n                })\r\n                .catch((exception: any) => {\r\n                    const error = new Error(exception?.message || exception?.error || exception)\r\n                    delete error?.stack\r\n                    return error\r\n                })\r\n        )\r\n    }\r\n    \r\n    /// ---------------------------------------------------------------------------------------------------------------\r\n    \r\n    public async addresses(): Promise<Record<string, PublicKeyHashString>> {\r\n        return this.batchApiMethod<PublicKeyHashString>(Methods.GetPkh)\r\n    }\r\n\r\n    public async balances(): Promise<Record<string, [PublicKeyHashString, Balance2]>> {\r\n        return this.batchApiPkhMethod<Balance2>(Methods.GetBalance2)\r\n    }\r\n\r\n    public async masterKeys(): Promise<Record<string, [PublicKeyHashString, string]>> {\r\n        return this.batchApiPkhMethodNoPkh<string>(Methods.MasterKeyExport)\r\n    }\r\n\r\n    public async publicKeys(): Promise<Record<string, [PublicKeyHashString, PublicKey]>> {\r\n        return this.batchApiPkhMethodNoPkh<Uint8Array>(Methods.GetPublicKey)\r\n            .then((results: Record<string, [PublicKeyHashString, Error | Uint8Array]>) => Object.fromEntries(\r\n                Object.entries(results).map(([url, [pkh, raw]]) => {\r\n                    if (raw && raw instanceof Error) {\r\n                        if ((raw as JsonRpcProviderError)?.error?.message) {\r\n                            raw = new Error((raw as JsonRpcProviderError)?.error?.message)\r\n                            delete raw.stack\r\n                        }\r\n                        return [url, [pkh, raw]]\r\n                    } else {\r\n                        return [url, [pkh, raw ? PublicKey.fromUint8Array(raw) : undefined]]\r\n                    }\r\n                })\r\n            ))\r\n    }\r\n\r\n    public async peers(): Promise<Array<PeerAddr>> {\r\n        return this.batchApiMethod<Array<PeerAddr>>(Methods.Peers)\r\n            .then((results: Record<string, PeerAddr[]>) => {\r\n                let peers: PeerAddr[] = []\r\n                Object.values(results).forEach((morePeers: Error | PeerAddr[]) => {\r\n                    if (!(morePeers instanceof Error)) { \r\n                        morePeers.forEach(peer => {\r\n                            if (!peers.includes(peer)) {\r\n                                peers.push(peer)\r\n                            }\r\n                        })\r\n                    }\r\n                })\r\n                return peers\r\n            })\r\n    }\r\n\r\n    public async stats(): Promise<Record<string, NodeStats>> {\r\n        return this.batchApiMethod<NodeStats>(Methods.NodeStats)\r\n    }\r\n\r\n    public async syncStatus(): Promise<any> {\r\n        return this.batchApiMethod<SyncStatus>(Methods.SyncStatus)\r\n    }\r\n\r\n    public async withdrawers(limit?: number, offset?: number): Promise<Record<PublicKeyHashString, [bigint, Nonce, number]>> {\r\n        return this.addresses()\r\n            .then(async (addresses: Record<string, Error | string>) => {\r\n                const promises = Object.entries(addresses).map(async ([url, validator]) => [\r\n                    url, \r\n                    validator instanceof Error \r\n                        ? undefined \r\n                        : await this.callApiMethod<Array<StakeEntry>>(\r\n                            url, \r\n                            Methods.QueryStakes, \r\n                            { \r\n                                filter: { validator },\r\n                                params: {\r\n                                    limit, offset,\r\n                                    since: 0,\r\n                                }\r\n                            },\r\n                        ),\r\n                ]);\r\n                return Promise.all(promises)\r\n            })\r\n            .then(entries => Object.fromEntries(entries.map(([url, stakes]) => {\r\n                if (stakes && stakes instanceof Error) {\r\n                    if ((stakes as JsonRpcProviderError)?.error?.message) {\r\n                        stakes = new Error((stakes as JsonRpcProviderError)?.error?.message)\r\n                        delete stakes.stack\r\n                    }\r\n                    return [url, ]\r\n                } else {\r\n\r\n                }\r\n                return [url, stakes]\r\n            })))\r\n            .then((results: Record<string, Error | Array<StakeEntry>>) => {\r\n                const max = (a: number, b: number) => a > b ? a : b;\r\n                const withdrawers: Record<PublicKeyHashString, [bigint, Nonce, number]> = {}\r\n                Object.values(results).forEach(moreEntries => {\r\n                    if (moreEntries && !(moreEntries instanceof Error)) { \r\n                        moreEntries.forEach(entry => {\r\n                            if (withdrawers[entry.key.withdrawer]) {\r\n                                withdrawers[entry.key.withdrawer][0] += entry.value.coins;\r\n                                withdrawers[entry.key.withdrawer][1] = max(\r\n                                    entry.value.nonce,\r\n                                    withdrawers[entry.key.withdrawer][1]\r\n                                );\r\n                                withdrawers[entry.key.withdrawer][2] += 1;\r\n                            } else {\r\n                                withdrawers[entry.key.withdrawer] = [\r\n                                    entry.value.coins,\r\n                                    entry.value.nonce,\r\n                                    1,\r\n                                ];\r\n                            }\r\n                        })\r\n                    }\r\n                })\r\n                return Object.fromEntries(Object.entries(withdrawers)\r\n                    .sort(([, [a,, ]], [, [b,,]]) => {\r\n                        if (a > b) return 1;\r\n                        else if (a < b) return -1;\r\n                        else return 0;\r\n                    })\r\n                )\r\n            })\r\n    }\r\n\r\n    /// ---------------------------------------------------------------------------------------------------------------\r\n\r\n    public async addPeers(peers: Array<string>): Promise<Record<string, Boolean>> {\r\n        return this.batchApiMethod<Boolean>(Methods.AddPeers, peers)\r\n    }\r\n\r\n    public async authorizeStakes(withdrawer: PublicKeyHashString): Promise<Record<string, [PublicKeyHashString, HexString]>> {\r\n        const msg = PublicKeyHash.fromBech32(withdrawer).toBytes32()\r\n        return this.batchApiPkhMethodNoPkh<StakeAuthorization>(Methods.AuthorizeStake, withdrawer)\r\n            .then((records: Record<string, [PublicKeyHashString, Error | StakeAuthorization]>) => Object.fromEntries(\r\n                Object.entries(records).map(([url, [pkh, authorization]]) => {\r\n                    if (authorization && authorization instanceof Error) {\r\n                        if ((authorization as JsonRpcProviderError)?.error?.message) {\r\n                            authorization = new Error((authorization as JsonRpcProviderError)?.error?.message)\r\n                            delete authorization.stack\r\n                        }\r\n                        return [url, [pkh, authorization]]\r\n                    } else if (authorization) {\r\n                        const signature = RecoverableSignature.fromKeyedSignature(authorization.signature, msg)\r\n                        const authcode = signature.pubKey.hash().toHexString() + signature.toHexString()\r\n                        return [url, [pkh, authcode]]\r\n                    } else {\r\n                        return [url, [pkh, undefined]]\r\n                    }\r\n                })\r\n            ))\r\n    }\r\n\r\n    public async clearPeers(): Promise<Record<string, Boolean>> {\r\n        return this.batchApiMethod<Boolean>(Methods.ClearPeers)\r\n    }\r\n\r\n    public async initializePeers(): Promise<Record<string, Boolean>> {\r\n        return this.batchApiMethod<Boolean>(Methods.InitializePeers)\r\n    }\r\n\r\n    public async rewind(epoch: Epoch): Promise<Record<string, Boolean>> {\r\n        return this.batchApiMethod<Boolean>(Methods.Rewind, [epoch, ])\r\n    }\r\n}\r\n"]}

package/dist/src/lib/rpc/provider.d.ts

@@ -0,0 +1,88 @@
+import { AxiosHeaders } from "axios";
+import { PublicKeyHashString, TransactionReceipt } from "../crypto/types";
+import { Epoch, Hash, Network, UtxoMetadata } from "../types";
+import { Balance2, Block, ConsensusConstants, DataRequestReport, Mempool, PeerAddr, Priorities, ProtocolInfo, QueryStakes, QueryStakingPowers, TransactionReport, SignalingInfo, StakeEntry, StakingPower, SuperblockReport, SupplyInfo, SyncStatus } from "./types";
+export interface IJsonRpcProvider {
+    network?: Network;
+    networkId?: number;
+    blocks(since: Epoch, limit: number): Promise<Array<[number, Hash]>>;
+    constants(): Promise<ConsensusConstants>;
+    holders(limit?: number): Promise<Record<PublicKeyHashString, Balance2>>;
+    mempool(): Promise<Mempool>;
+    powers(params?: QueryStakingPowers): Promise<Array<StakingPower>>;
+    priorities(): Promise<Priorities>;
+    protocolInfo(): Promise<ProtocolInfo>;
+    stakes(params: QueryStakes): Promise<Array<StakeEntry>>;
+    supplyInfo(): Promise<SupplyInfo>;
+    syncStatus(): Promise<any>;
+    wips(): Promise<SignalingInfo>;
+    witnesses(): Promise<number>;
+    getBalance(pkh: PublicKeyHashString): Promise<Balance2>;
+    getBlock(blockHash: Hash, showTransactionHashes?: boolean): Promise<Block>;
+    getDataRequest(drTxHash: Hash): Promise<DataRequestReport>;
+    getSuperblock(epoch: Epoch): Promise<SuperblockReport>;
+    getTransaction(txHash: Hash): Promise<TransactionReport>;
+    getTransactionReceipt(txHash: Hash): Promise<TransactionReceipt>;
+    getUtxos(pkh: PublicKeyHashString, smallestFirst?: boolean): Promise<Array<UtxoMetadata>>;
+    sendRawTransaction(tx: any): Promise<boolean>;
+}
+export declare class JsonRpcProviderError extends Error {
+    readonly error?: any;
+    readonly method: string;
+    readonly params: any[];
+    constructor(method: string, params: any[], error?: any);
+}
+export declare class JsonRpcProvider implements IJsonRpcProvider {
+    readonly endpoints: string[];
+    static receipts: Record<Hash, TransactionReceipt>;
+    protected _constants?: ConsensusConstants;
+    protected _headers: AxiosHeaders;
+    /**
+     * Create and initialize a JsonRpcProvider object connected to the default Wit/RPC endpoint.
+     * Defaults to https://rpc-01.witnet.io if no WITNET_SDK_PROVIDER_URL envar is settled
+     * on the environment.
+     */
+    static fromEnv(url?: string): Promise<JsonRpcProvider>;
+    /**
+     * Create and initialize a JsonRpcProvider object connected to the specified Wit/RPC endpoint.
+     * @param url Wit/RPC endpoint URL.
+     */
+    static fromURL(url: string): Promise<JsonRpcProvider>;
+    constructor(url?: string);
+    get network(): Network | undefined;
+    get networkId(): number | undefined;
+    protected nextURL(): string;
+    protected callApiMethod<T>(method: string, params?: Array<any> | any): Promise<Error | any>;
+    /**
+     * Get the list of block hashes within given range, as known by the provider.
+     * @param {number} since - First epoch for which to return block hashes. If negative, return block hashes from the last n epochs.
+         * @param {number} limit - Number of block hashes to return. If negative, return the last n block hashes from this epoch range.
+     */
+    blocks(since?: number, limit?: number): Promise<Array<[number, Hash]>>;
+    constants(): Promise<ConsensusConstants>;
+    holders(minBalance?: number, maxBalance?: number): Promise<Record<PublicKeyHashString, Balance2>>;
+    knownPeers(): Promise<Array<PeerAddr>>;
+    mempool(): Promise<Mempool>;
+    priorities(): Promise<Priorities>;
+    protocolInfo(): Promise<ProtocolInfo>;
+    powers(query?: QueryStakingPowers): Promise<Array<StakingPower>>;
+    stakes(query?: QueryStakes): Promise<Array<StakeEntry>>;
+    syncStatus(): Promise<SyncStatus>;
+    wips(): Promise<SignalingInfo>;
+    witnesses(_since?: number): Promise<number>;
+    getBalance(pkh: PublicKeyHashString): Promise<Balance2>;
+    /**
+     * Get block info by hash
+     * @param {Hash} blockHash - Hash of the block that we are querying.
+     * @param {boolean} showTransactionHash - Whether to include an extra field containing array of transaction hashes.
+     */
+    getBlock(blockHash: Hash, showTransactionHash?: boolean): Promise<Block>;
+    getDataRequest(drTxHash: Hash): Promise<DataRequestReport>;
+    getSuperblock(epoch: Epoch): Promise<SuperblockReport>;
+    getTransaction(txHash: Hash): Promise<TransactionReport>;
+    getTransactionReceipt(txHash: Hash): Promise<TransactionReceipt>;
+    getUtxos(pkh: PublicKeyHashString, smallFirst?: boolean): Promise<Array<UtxoMetadata>>;
+    sendRawTransaction(transaction: any): Promise<boolean>;
+    supplyInfo(): Promise<SupplyInfo>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/src/lib/rpc/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/lib/rpc/provider.ts"],"names":[],"mappings":"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"}