@witnet/sdk 1.0.0-beta.0

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

@@ -0,0 +1,336 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcProvider = exports.JsonRpcProviderError = void 0;
+const axios_1 = __importStar(require("axios"));
+const jsonBig = require('json-bigint');
+const protobufjs_1 = require("protobufjs");
+const protoRoot = protobufjs_1.Root.fromJSON(require("../../../witnet/witnet.proto.json"));
+const protoBuf = protoRoot.lookupType("ConsensusConstants");
+const types_1 = require("../crypto/types");
+const utils = __importStar(require("../utils"));
+const types_2 = require("./types");
+class JsonRpcProviderError extends Error {
+    constructor(method, params, error) {
+        super(`${method}(${JSON.stringify(params)}): ${JSON.stringify(error)})`);
+        delete error?.stack;
+        this.error = error;
+        this.method = method;
+        this.params = params;
+    }
+}
+exports.JsonRpcProviderError = JsonRpcProviderError;
+class JsonRpcProvider {
+    /**
+     * 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 async fromEnv(url) {
+        return JsonRpcProvider.fromURL(url || process.env.WITNET_SDK_PROVIDER_URL || "https://rpc-01.witnet.io");
+    }
+    /**
+     * Create and initialize a JsonRpcProvider object connected to the specified Wit/RPC endpoint.
+     * @param url Wit/RPC endpoint URL.
+     */
+    static async fromURL(url) {
+        const provider = new JsonRpcProvider(url);
+        return provider.constants().then(() => provider);
+    }
+    constructor(url) {
+        this.endpoints = [];
+        if (url !== undefined) {
+            const urls = url.replaceAll(',', ';').split(';');
+            urls.forEach(url => {
+                const [schema,] = utils.parseURL(url);
+                if (!schema.startsWith("http://") && !schema.startsWith("https://")) {
+                    throw Error(`Witnet.JsonRpcProvider: unsupported URL schema ${schema}`);
+                }
+            });
+            this.endpoints = urls;
+        }
+        else {
+            this.endpoints.push(process.env.WITNET_SDK_PROVIDER_URL || "https://rpc-01.witnet.io");
+        }
+        this._headers = new axios_1.AxiosHeaders({
+            "Content-Type": "application/json"
+        });
+    }
+    get network() {
+        if (this._constants) {
+            return this._constants.bootstrapping_committee[0].startsWith('wit') ? "mainnet" : "testnet";
+        }
+        else {
+            return undefined;
+        }
+    }
+    get networkId() {
+        if (this._constants) {
+            const obj = {};
+            obj.activityPeriod = this._constants.activity_period;
+            obj.bootstrapHash = { SHA256: Array.from(utils.fromHexString(this._constants.bootstrap_hash)) };
+            obj.bootstrappingCommittee = this._constants.bootstrapping_committee;
+            obj.checkpointZeroTimestamp = this._constants.checkpoint_zero_timestamp;
+            obj.checkpointsPeriod = this._constants.checkpoints_period;
+            obj.collateralAge = this._constants.collateral_age;
+            obj.collateralMinimum = this._constants.collateral_minimum;
+            obj.epochsWithMinimumDifficulty = this._constants.epochs_with_minimum_difficulty;
+            obj.extraRounds = this._constants.extra_rounds;
+            obj.genesisHash = { SHA256: Array.from(utils.fromHexString(this._constants.genesis_hash)) };
+            obj.halvingPeriod = this._constants.halving_period;
+            obj.initialBlockReward = this._constants.initial_block_reward;
+            obj.maxDrWeight = this._constants.max_dr_weight;
+            obj.maxVtWeight = this._constants.max_vt_weight;
+            if (this._constants.minimum_difficulty > 0)
+                obj.minimumDifficulty = this._constants.minimum_difficulty;
+            obj.miningBackupFactor = this._constants.mining_backup_factor;
+            obj.miningReplicationFactor = this._constants.mining_replication_factor;
+            obj.reputationExpireAlphaDiff = this._constants.reputation_expire_alpha_diff;
+            obj.reputationIssuance = this._constants.reputation_issuance;
+            obj.reputationIssuanceStop = this._constants.reputation_issuance_stop;
+            obj.reputationPenalizationFactor = this._constants.reputation_penalization_factor;
+            obj.superblockCommitteeDecreasingPeriod = this._constants.superblock_committee_decreasing_period;
+            obj.superblockCommitteeDecreasingStep = this._constants.superblock_committee_decreasing_step;
+            obj.superblockPeriod = this._constants.superblock_period;
+            obj.superblockSigningCommitteeSize = this._constants.superblock_signing_committee_size;
+            // console.log(obj)
+            const message = protoBuf.fromObject(obj);
+            // console.log(message)
+            const buffer = protoBuf.encode(message).finish();
+            const hash = utils.toHexString(utils.sha256(buffer));
+            // console.log(hash)
+            const hex = hash.substring(0, 4);
+            return parseInt(hex, 16);
+        }
+        return undefined;
+    }
+    nextURL() {
+        return this.endpoints[Math.floor(Math.random() * this.endpoints.length)];
+    }
+    async callApiMethod(method, params) {
+        const url = this.nextURL();
+        return axios_1.default
+            .post(url, {
+            jsonrpc: '2.0',
+            id: +new Date(),
+            method,
+            params,
+        }, {
+            headers: this._headers,
+            transformResponse: function (response) { return jsonBig().parse(response); },
+        }).then((response) => {
+            if (response?.error || response?.data?.error) {
+                throw new JsonRpcProviderError(method, params, response?.error || response?.data?.error);
+            }
+            else
+                return response?.data?.result;
+        });
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    /**
+     * 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.
+     */
+    async blocks(since = -1, limit = 1) {
+        return this.callApiMethod(types_2.Methods.GetBlockChain, [since, limit,]);
+    }
+    /// Get consensus constants used by the node
+    async constants() {
+        if (!this._constants) {
+            return this
+                .callApiMethod(types_2.Methods.GetConsensusConstants)
+                .then((constants) => {
+                this._constants = constants;
+                return constants;
+            });
+        }
+        else {
+            return this._constants;
+        }
+    }
+    /// Get limited list of currently top holders, as known by the provider.
+    async holders(minBalance = 0, maxBalance) {
+        return this
+            .callApiMethod(types_2.Methods.GetBalance2, {
+            all: {
+                minBalance,
+                ...maxBalance ? { maxBalance } : {}
+            }
+        }).then((balances) => {
+            const reverseCompare = (a, b) => {
+                const a_tot = a.locked + a.unlocked + a.staked;
+                const b_tot = b.locked + b.unlocked + b.staked;
+                if (a_tot < b_tot)
+                    return 1;
+                else if (a_tot > b_tot)
+                    return -1;
+                else
+                    return 0;
+            };
+            return Object.fromEntries(Object.entries(balances)
+                .sort((a, b) => reverseCompare(a[1], b[1])));
+        });
+    }
+    /// Get list of known peers
+    async knownPeers() {
+        return this.callApiMethod(types_2.Methods.KnownPeers);
+    }
+    /// Get all the pending transactions
+    async mempool() {
+        return this.callApiMethod(types_2.Methods.GetMempool);
+    }
+    /// Get priority and time-to-block estimations for different priority tiers.
+    async priorities() {
+        return this.callApiMethod(types_2.Methods.Priority);
+    }
+    /// Get information about protocol versions and which version is currently being enforced.
+    async protocolInfo() {
+        return this.callApiMethod(types_2.Methods.Protocol);
+    }
+    /// Get a full list of staking powers ordered by rank
+    async powers(query) {
+        return this.callApiMethod(types_2.Methods.QueryStakingPowers, query);
+    }
+    /// Get a full list of current stake entries  Query the amount of nanowits staked by an address.
+    async stakes(query) {
+        return this
+            .callApiMethod(types_2.Methods.QueryStakes, query)
+            .catch(err => {
+            if (err?.error?.message && err.error.message.indexOf("not registered") > -1) {
+                return [];
+            }
+            else {
+                throw err;
+            }
+        });
+    }
+    /// Get node status
+    async syncStatus() {
+        return this.callApiMethod(types_2.Methods.SyncStatus);
+    }
+    async wips() {
+        return this.callApiMethod(types_2.Methods.SignalingInfo);
+    }
+    async witnesses(_since) {
+        // todo: witnesses estimation should instead be computed in proportion to
+        //       ratio of validators that have honestly witnessed data requests
+        //       vs validators that have honestly witnessed data requests and
+        //       never revealed "i passed" out of majority, 
+        //       within the specified range of epochs.
+        let census = 0;
+        return this
+            .stakes({ params: { distinct: true } }) // todo: implement `count` flag on IJsonRpcProvider.stakes()
+            .then(records => {
+            census = records.length;
+            return this.blocks(-16, 16); // todo: blocks() should return epoch, hash and validator pkh for each block
+        })
+            .then(records => {
+            return Promise.all(records.map(record => this.getBlock(record[1])));
+        })
+            .then(blocks => {
+            const validators = [];
+            blocks.map(block => {
+                const pkh = types_1.PublicKey.fromProtobuf(block.block_sig.public_key).hash().toBech32(this.network);
+                if (!validators.includes(pkh))
+                    validators.push(pkh);
+            });
+            return Math.min(validators.length, Math.floor(this.network === "testnet" ? census / 2 : census / 4));
+        });
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    /// Get balance
+    async getBalance(pkh) {
+        return this
+            .callApiMethod(types_2.Methods.GetBalance2, { pkh })
+            .then((balance) => ({
+            locked: BigInt(balance.locked),
+            staked: BigInt(balance.staked),
+            unlocked: BigInt(balance.unlocked),
+        }));
+    }
+    /**
+     * 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.
+     */
+    async getBlock(blockHash, showTransactionHash = false) {
+        return this.callApiMethod(types_2.Methods.GetBlock, [blockHash, showTransactionHash,]);
+    }
+    async getDataRequest(drTxHash) {
+        return this.callApiMethod(types_2.Methods.DataRequestReport, [drTxHash,]);
+    }
+    /// Get the blocks that pertain to the superblock index
+    async getSuperblock(epoch) {
+        return this.callApiMethod(types_2.Methods.GetSuperblock, { "block_epoch": epoch });
+    }
+    async getTransaction(txHash) {
+        return this.callApiMethod(types_2.Methods.GetTransaction, [txHash,]);
+    }
+    async getTransactionReceipt(txHash) {
+        // todo: fetch/update receipt from provider, if not cached
+        return JsonRpcProvider.receipts[txHash];
+    }
+    /// Get utxos
+    async getUtxos(pkh, smallFirst = true) {
+        return this
+            .callApiMethod(types_2.Methods.GetUtxoInfo, [pkh,])
+            .then((result) => {
+            const inversor = smallFirst ? 1 : -1;
+            return result.utxos.sort((a, b) => {
+                if (a.value > b.value)
+                    return inversor;
+                else if (a.value < b.value)
+                    return -inversor;
+                else
+                    return 0;
+            }).map((utxo) => ({
+                ...utxo,
+                value: BigInt(utxo.value),
+            }));
+        });
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    async sendRawTransaction(transaction) {
+        return this.callApiMethod(types_2.Methods.Inventory, { transaction });
+    }
+    /// Get supply info
+    async supplyInfo() {
+        return this.callApiMethod(types_2.Methods.GetSupplyInfo);
+    }
+}
+exports.JsonRpcProvider = JsonRpcProvider;
+JsonRpcProvider.receipts = {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../src/lib/rpc/provider.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAsD;AACtD,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AACvC,2CAA8C;AAC9C,MAAM,SAAS,GAAG,iBAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,CAAA;AAClF,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAA;AAE3D,2CAAoF;AAEpF,gDAAiC;AAEjC,mCAMgB;AA8BhB,MAAa,oBAAqB,SAAQ,KAAK;IAI3C,YAAY,MAAc,EAAE,MAAa,EAAE,KAAW;QAClD,KAAK,CAAC,GAAG,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACxE,OAAO,KAAK,EAAE,KAAK,CAAA;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACxB,CAAC;CACJ;AAXD,oDAWC;AAED,MAAa,eAAe;IASxB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAY;QAC7B,OAAO,eAAe,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,0BAA0B,CAAC,CAAA;IAC5G,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAW;QAC5B,MAAM,QAAQ,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,CAAA;QACzC,OAAO,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAA;IACpD,CAAC;IAED,YAAY,GAAY;QACpB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;QACnB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACpB,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAChD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACf,MAAM,CAAC,MAAM,EAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAA;gBACtC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;oBAClE,MAAM,KAAK,CAAC,kDAAkD,MAAM,EAAE,CAAC,CAAA;gBAC3E,CAAC;YACL,CAAC,CAAC,CAAA;YACF,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACzB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,0BAA0B,CAAC,CAAA;QAC1F,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,oBAAY,CAAC;YAC7B,cAAc,EAAE,kBAAkB;SACrC,CAAC,CAAA;IACN,CAAC;IAED,IAAW,OAAO;QACd,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,OAAO,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA,CAAC,CAAC,SAAS,CAAA;QAC9F,CAAC;aAAM,CAAC;YACJ,OAAO,SAAS,CAAA;QACpB,CAAC;IACL,CAAC;IAED,IAAW,SAAS;QAChB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,MAAM,GAAG,GAAQ,EAAE,CAAA;YACnB,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;YACrD,GAAG,CAAC,aAAa,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,EAAE,CAAA;YAC/F,GAAG,CAAC,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAA;YACpE,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,UAAU,CAAC,yBAAyB,CAAA;YACvE,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAA;YAC1D,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAA;YAClD,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAA;YAC1D,GAAG,CAAC,2BAA2B,GAAG,IAAI,CAAC,UAAU,CAAC,8BAA8B,CAAA;YAChF,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAA;YAC9C,GAAG,CAAC,WAAW,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,CAAA;YAC3F,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAA;YAClD,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAA;YAC7D,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAA;YAC/C,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAA;YAC/C,IAAI,IAAI,CAAC,UAAU,CAAC,kBAAkB,GAAG,CAAC;gBAAE,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAA;YACtG,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAA;YAC7D,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,UAAU,CAAC,yBAAyB,CAAA;YACvE,GAAG,CAAC,yBAAyB,GAAG,IAAI,CAAC,UAAU,CAAC,4BAA4B,CAAA;YAC5E,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAA;YAC5D,GAAG,CAAC,sBAAsB,GAAG,IAAI,CAAC,UAAU,CAAC,wBAAwB,CAAA;YACrE,GAAG,CAAC,4BAA4B,GAAG,IAAI,CAAC,UAAU,CAAC,8BAA8B,CAAA;YACjF,GAAG,CAAC,mCAAmC,GAAG,IAAI,CAAC,UAAU,CAAC,sCAAsC,CAAA;YAChG,GAAG,CAAC,iCAAiC,GAAG,IAAI,CAAC,UAAU,CAAC,oCAAoC,CAAA;YAC5F,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAA;YACxD,GAAG,CAAC,8BAA8B,GAAG,IAAI,CAAC,UAAU,CAAC,iCAAiC,CAAA;YACtF,mBAAmB;YACnB,MAAM,OAAO,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;YACxC,uBAAuB;YACvB,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAA;YAChD,MAAM,IAAI,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;YACpD,oBAAoB;YACpB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;YAChC,OAAO,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QAC5B,CAAC;QACD,OAAO,SAAS,CAAA;IACpB,CAAC;IAES,OAAO;QACb,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;IAC5E,CAAC;IAES,KAAK,CAAC,aAAa,CAAI,MAAc,EAAE,MAAyB;QACtE,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;QAC1B,OAAO,eAAK;aACP,IAAI,CACD,GAAG,EACH;YACI,OAAO,EAAE,KAAK;YACd,EAAE,EAAE,CAAE,IAAI,IAAI,EAAE;YAChB,MAAM;YACN,MAAM;SACT,EACD;YACI,OAAO,EAAE,IAAI,CAAC,QAAQ;YACtB,iBAAiB,EAAE,UAAS,QAAQ,IAAI,OAAO,OAAO,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA,CAAC,CAAC;SAC7E,CAEJ,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;YACrB,IAAI,QAAQ,EAAE,KAAK,IAAI,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;gBAC3C,MAAM,IAAI,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAE7F,CAAC;;gBAAM,OAAO,QAAQ,EAAE,IAAI,EAAE,MAAW,CAAC;QAC9C,CAAC,CAAC,CAAA;IACV,CAAC;IAED,mHAAmH;IAEnH;;;;OAIG;IACI,KAAK,CAAC,MAAM,CAAC,QAAgB,CAAC,CAAC,EAAE,QAAgB,CAAC;QACrD,OAAO,IAAI,CAAC,aAAa,CAAiB,eAAO,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,EAAG,CAAC,CAAC;IACvF,CAAC;IAED,4CAA4C;IACrC,KAAK,CAAC,SAAS;QAClB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACnB,OAAO,IAAI;iBACN,aAAa,CAAqB,eAAO,CAAC,qBAAqB,CAAC;iBAChE,IAAI,CAAC,CAAC,SAA6B,EAAE,EAAE;gBACpC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;gBAC3B,OAAO,SAAS,CAAA;YACpB,CAAC,CAAC,CAAA;QACV,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC,UAAU,CAAA;QAC1B,CAAC;IACL,CAAC;IAED,wEAAwE;IACjE,KAAK,CAAC,OAAO,CAAC,UAAU,GAAG,CAAC,EAAE,UAAmB;QACpD,OAAO,IAAI;aACN,aAAa,CAAuC,eAAO,CAAC,WAAW,EAAE;YACtE,GAAG,EAAE;gBACD,UAAU;gBACV,GAAI,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE;aACvC;SACJ,CAAC,CAAC,IAAI,CAAC,CAAC,QAA+C,EAAE,EAAE;YACxD,MAAM,cAAc,GAAG,CAAC,CAAW,EAAE,CAAW,EAAE,EAAE;gBAChD,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAA;gBAC9C,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAA;gBAC9C,IAAI,KAAK,GAAG,KAAK;oBAAE,OAAO,CAAC,CAAC;qBACvB,IAAI,KAAK,GAAG,KAAK;oBAAE,OAAO,CAAC,CAAC,CAAC;;oBAC7B,OAAO,CAAC,CAAC;YAClB,CAAC,CAAA;YACD,OAAO,MAAM,CAAC,WAAW,CACrB,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC;iBACnB,IAAI,CAAC,CAAC,CAAwB,EAAE,CAAwB,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAa,EAAE,CAAC,CAAC,CAAC,CAAa,CAAC,CAAC,CACxH,CAAC;QACN,CAAC,CAAC,CAAA;IACV,CAAC;IAED,2BAA2B;IACpB,KAAK,CAAC,UAAU;QACnB,OAAO,IAAI,CAAC,aAAa,CAAkB,eAAO,CAAC,UAAU,CAAC,CAAC;IACnE,CAAC;IAED,oCAAoC;IAC7B,KAAK,CAAC,OAAO;QAChB,OAAO,IAAI,CAAC,aAAa,CAAU,eAAO,CAAC,UAAU,CAAC,CAAC;IAC3D,CAAC;IAED,4EAA4E;IACrE,KAAK,CAAC,UAAU;QACnB,OAAO,IAAI,CAAC,aAAa,CAAa,eAAO,CAAC,QAAQ,CAAC,CAAA;IAC3D,CAAC;IAED,0FAA0F;IACnF,KAAK,CAAC,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAe,eAAO,CAAC,QAAQ,CAAC,CAAA;IAC7D,CAAC;IAED,qDAAqD;IAC9C,KAAK,CAAC,MAAM,CAAC,KAA0B;QAC1C,OAAO,IAAI,CAAC,aAAa,CAAsB,eAAO,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAA;IACrF,CAAC;IAED,gGAAgG;IACzF,KAAK,CAAC,MAAM,CAAC,KAAmB;QACnC,OAAO,IAAI;aACN,aAAa,CAAoB,eAAO,CAAC,WAAW,EAAE,KAAK,CAAC;aAC5D,KAAK,CAAC,GAAG,CAAC,EAAE;YACT,IAAI,GAAG,EAAE,KAAK,EAAE,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC1E,OAAO,EAAE,CAAA;YACb,CAAC;iBAAM,CAAC;gBACJ,MAAM,GAAG,CAAA;YACb,CAAC;QACL,CAAC,CAAC,CAAA;IACV,CAAC;IAED,mBAAmB;IACZ,KAAK,CAAC,UAAU;QACnB,OAAO,IAAI,CAAC,aAAa,CAAa,eAAO,CAAC,UAAU,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,IAAI;QACb,OAAO,IAAI,CAAC,aAAa,CAAgB,eAAO,CAAC,aAAa,CAAC,CAAA;IACnE,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,MAAe;QAClC,yEAAyE;QACzE,uEAAuE;QACvE,qEAAqE;QACrE,oDAAoD;QACpD,8CAA8C;QAC9C,IAAI,MAAM,GAAG,CAAC,CAAA;QACd,OAAO,IAAI;aACN,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAC,CAAC,CAAC,4DAA4D;aAClG,IAAI,CAAC,OAAO,CAAC,EAAE;YACZ,MAAM,GAAG,OAAO,CAAC,MAAM,CAAA;YACvB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA,CAAC,4EAA4E;QAC5G,CAAC,CAAC;aACD,IAAI,CAAC,OAAO,CAAC,EAAE;YACZ,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACvE,CAAC,CAAC;aACD,IAAI,CAAC,MAAM,CAAC,EAAE;YACX,MAAM,UAAU,GAA+B,EAAE,CAAA;YACjD,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBACf,MAAM,GAAG,GAAG,iBAAS,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;gBAC5F,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC;oBAAE,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACxD,CAAC,CAAC,CAAA;YACF,OAAO,IAAI,CAAC,GAAG,CACX,UAAU,CAAC,MAAM,EACjB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CACnE,CAAA;QACL,CAAC,CAAC,CAAA;IACV,CAAC;IAED,mHAAmH;IACnH,eAAe;IACR,KAAK,CAAC,UAAU,CAAC,GAAwB;QAC5C,OAAO,IAAI;aACN,aAAa,CAAW,eAAO,CAAC,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC;aACrD,IAAI,CAAC,CAAC,OAAiB,EAAE,EAAE,CAAC,CAAC;YAC1B,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YAC9B,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;YAC9B,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC;SACrC,CAAC,CAAC,CAAA;IACX,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,QAAQ,CACb,SAAe,EACf,mBAAmB,GAAG,KAAK;QAG/B,OAAO,IAAI,CAAC,aAAa,CAAQ,eAAO,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,mBAAmB,EAAG,CAAC,CAAA;IAC1F,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,QAAc;QACtC,OAAO,IAAI,CAAC,aAAa,CAAoB,eAAO,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAG,CAAC,CAAA;IACzF,CAAC;IAED,uDAAuD;IAChD,KAAK,CAAC,aAAa,CAAC,KAAY;QACnC,OAAO,IAAI,CAAC,aAAa,CAAmB,eAAO,CAAC,aAAa,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IACjG,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,MAAY;QACpC,OAAO,IAAI,CAAC,aAAa,CAAoB,eAAO,CAAC,cAAc,EAAE,CAAC,MAAM,EAAG,CAAC,CAAC;IACrF,CAAC;IAEM,KAAK,CAAC,qBAAqB,CAAC,MAAY;QAC3C,0DAA0D;QAC1D,OAAO,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IAC3C,CAAC;IAED,aAAa;IACN,KAAK,CAAC,QAAQ,CAAC,GAAwB,EAAE,UAAU,GAAG,IAAI;QAC7D,OAAO,IAAI;aACN,aAAa,CAAW,eAAO,CAAC,WAAW,EAAE,CAAC,GAAG,EAAG,CAAC;aACrD,IAAI,CAAC,CAAC,MAAgB,EAAE,EAAE;YACvB,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YACpC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC9B,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK;oBAAE,OAAO,QAAQ,CAAC;qBAClC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK;oBAAE,OAAO,CAAE,QAAQ,CAAC;;oBACzC,OAAO,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC;gBAC5B,GAAG,IAAI;gBACP,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;aAC5B,CAAC,CAAC,CAAA;QACP,CAAC,CAAC,CAAA;IACV,CAAC;IAED,mHAAmH;IAC5G,KAAK,CAAC,kBAAkB,CAAC,WAAgB;QAC5C,OAAO,IAAI,CAAC,aAAa,CAAU,eAAO,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,CAAC,CAAA;IAC1E,CAAC;IAED,mBAAmB;IACZ,KAAK,CAAC,UAAU;QACnB,OAAO,IAAI,CAAC,aAAa,CAAa,eAAO,CAAC,aAAa,CAAC,CAAA;IAChE,CAAC;;AA1TL,0CA2TC;AAvTiB,wBAAQ,GAAqC,EAAE,CAAC","sourcesContent":["import { default as axios, AxiosHeaders } from \"axios\"\r\nconst jsonBig = require('json-bigint');\r\nimport { Root as ProtoRoot } from \"protobufjs\"\r\nconst protoRoot = ProtoRoot.fromJSON(require(\"../../../witnet/witnet.proto.json\")) \r\nconst protoBuf = protoRoot.lookupType(\"ConsensusConstants\")\r\n\r\nimport { PublicKey, PublicKeyHashString, TransactionReceipt } from \"../crypto/types\"\r\nimport { Epoch, Hash, Network, UtxoMetadata } from \"../types\"\r\nimport * as utils from \"../utils\"\r\n\r\nimport {\r\n    Balance, Balance2, Block, ConsensusConstants, DataRequestReport, \r\n    Mempool, Methods, PeerAddr, Priorities, ProtocolInfo, \r\n    QueryStakes, QueryStakingPowers,\r\n    TransactionReport, SignalingInfo, StakeEntry, StakingPower, \r\n    SuperblockReport, SupplyInfo, SyncStatus, UtxoInfo,\r\n} from \"./types\"\r\n\r\nexport interface IJsonRpcProvider {\r\n    network?: Network;\r\n    networkId?: number;\r\n    \r\n    blocks(since: Epoch, limit: number): Promise<Array<[number, Hash/*, PublicKeyHashString*/]>>;\r\n    constants(): Promise<ConsensusConstants>;\r\n    holders(limit?: number): Promise<Record<PublicKeyHashString, Balance2>> \r\n    mempool(): Promise<Mempool>;\r\n    powers(params?: QueryStakingPowers): Promise<Array<StakingPower>>;\r\n    priorities(): Promise<Priorities>;\r\n    protocolInfo(): Promise<ProtocolInfo>;\r\n    stakes(params: QueryStakes): Promise<Array<StakeEntry>>; \r\n    supplyInfo(): Promise<SupplyInfo>;\r\n    syncStatus(): Promise<any>;\r\n    wips(): Promise<SignalingInfo>;\r\n    witnesses(): Promise<number>;\r\n\r\n    getBalance(pkh: PublicKeyHashString): Promise<Balance2>;\r\n    getBlock(blockHash: Hash, showTransactionHashes?: boolean): Promise<Block>;\r\n    getDataRequest(drTxHash: Hash): Promise<DataRequestReport>;\r\n    getSuperblock(epoch: Epoch): Promise<SuperblockReport>;\r\n    getTransaction(txHash: Hash): Promise<TransactionReport>;\r\n    getTransactionReceipt(txHash: Hash): Promise<TransactionReceipt>;\r\n    getUtxos(pkh: PublicKeyHashString, smallestFirst?: boolean): Promise<Array<UtxoMetadata>>;\r\n        \r\n    sendRawTransaction(tx: any): Promise<boolean>;\r\n}\r\n\r\nexport class JsonRpcProviderError extends Error {\r\n    readonly error?: any;\r\n    readonly method: string;\r\n    readonly params: any[];\r\n    constructor(method: string, params: any[], error?: any) {\r\n        super(`${method}(${JSON.stringify(params)}): ${JSON.stringify(error)})`)\r\n        delete error?.stack\r\n        this.error = error\r\n        this.method = method\r\n        this.params = params\r\n    }\r\n}\r\n\r\nexport class JsonRpcProvider implements IJsonRpcProvider {\r\n    \r\n    public readonly endpoints: string[]\r\n\r\n    public static receipts: Record<Hash, TransactionReceipt> = {};\r\n\r\n    protected _constants?: ConsensusConstants\r\n    protected _headers: AxiosHeaders;\r\n    \r\n    /**\r\n     * Create and initialize a JsonRpcProvider object connected to the default Wit/RPC endpoint.\r\n     * Defaults to https://rpc-01.witnet.io if no WITNET_SDK_PROVIDER_URL envar is settled\r\n     * on the environment.\r\n     */\r\n    static async fromEnv(url?: string): Promise<JsonRpcProvider> {\r\n        return JsonRpcProvider.fromURL(url || process.env.WITNET_SDK_PROVIDER_URL || \"https://rpc-01.witnet.io\")\r\n    }\r\n    \r\n    /**\r\n     * Create and initialize a JsonRpcProvider object connected to the specified Wit/RPC endpoint.\r\n     * @param url Wit/RPC endpoint URL.\r\n     */\r\n    static async fromURL(url: string): Promise<JsonRpcProvider> {\r\n        const provider = new JsonRpcProvider(url)\r\n        return provider.constants().then(() => provider)\r\n    }\r\n\r\n    constructor(url?: string) {\r\n        this.endpoints = []\r\n        if (url !== undefined) {\r\n            const urls = url.replaceAll(',', ';').split(';')\r\n            urls.forEach(url => {\r\n                const [schema, ] = utils.parseURL(url)\r\n                if (!schema.startsWith(\"http://\") && !schema.startsWith(\"https://\")) {\r\n                    throw Error(`Witnet.JsonRpcProvider: unsupported URL schema ${schema}`)\r\n                }\r\n            })\r\n            this.endpoints = urls\r\n        } else {\r\n            this.endpoints.push(process.env.WITNET_SDK_PROVIDER_URL || \"https://rpc-01.witnet.io\")\r\n        }\r\n        this._headers = new AxiosHeaders({ \r\n            \"Content-Type\": \"application/json\" \r\n        })\r\n    }\r\n\r\n    public get network(): Network | undefined {\r\n        if (this._constants) {\r\n            return this._constants.bootstrapping_committee[0].startsWith('wit') ? \"mainnet\": \"testnet\"\r\n        } else {\r\n            return undefined\r\n        }\r\n    }\r\n\r\n    public get networkId(): number | undefined {\r\n        if (this._constants) {\r\n            const obj: any = {}\r\n            obj.activityPeriod = this._constants.activity_period;\r\n            obj.bootstrapHash = { SHA256: Array.from(utils.fromHexString(this._constants.bootstrap_hash)) }\r\n            obj.bootstrappingCommittee = this._constants.bootstrapping_committee\r\n            obj.checkpointZeroTimestamp = this._constants.checkpoint_zero_timestamp\r\n            obj.checkpointsPeriod = this._constants.checkpoints_period\r\n            obj.collateralAge = this._constants.collateral_age\r\n            obj.collateralMinimum = this._constants.collateral_minimum\r\n            obj.epochsWithMinimumDifficulty = this._constants.epochs_with_minimum_difficulty\r\n            obj.extraRounds = this._constants.extra_rounds\r\n            obj.genesisHash = { SHA256: Array.from(utils.fromHexString(this._constants.genesis_hash)) }\r\n            obj.halvingPeriod = this._constants.halving_period\r\n            obj.initialBlockReward = this._constants.initial_block_reward\r\n            obj.maxDrWeight = this._constants.max_dr_weight\r\n            obj.maxVtWeight = this._constants.max_vt_weight\r\n            if (this._constants.minimum_difficulty > 0) obj.minimumDifficulty = this._constants.minimum_difficulty\r\n            obj.miningBackupFactor = this._constants.mining_backup_factor\r\n            obj.miningReplicationFactor = this._constants.mining_replication_factor\r\n            obj.reputationExpireAlphaDiff = this._constants.reputation_expire_alpha_diff\r\n            obj.reputationIssuance = this._constants.reputation_issuance\r\n            obj.reputationIssuanceStop = this._constants.reputation_issuance_stop\r\n            obj.reputationPenalizationFactor = this._constants.reputation_penalization_factor\r\n            obj.superblockCommitteeDecreasingPeriod = this._constants.superblock_committee_decreasing_period\r\n            obj.superblockCommitteeDecreasingStep = this._constants.superblock_committee_decreasing_step\r\n            obj.superblockPeriod = this._constants.superblock_period\r\n            obj.superblockSigningCommitteeSize = this._constants.superblock_signing_committee_size\r\n            // console.log(obj)\r\n            const message = protoBuf.fromObject(obj)\r\n            // console.log(message)\r\n            const buffer = protoBuf.encode(message).finish()\r\n            const hash = utils.toHexString(utils.sha256(buffer)) \r\n            // console.log(hash)\r\n            const hex = hash.substring(0, 4)\r\n            return parseInt(hex, 16)\r\n        } \r\n        return undefined\r\n    }\r\n    \r\n    protected nextURL(): string {\r\n        return this.endpoints[Math.floor(Math.random() * this.endpoints.length)]\r\n    }\r\n    \r\n    protected async callApiMethod<T>(method: string, params?: Array<any> | any ): Promise<Error | any> {\r\n        const url = this.nextURL()\r\n        return axios\r\n            .post(\r\n                url,\r\n                {\r\n                    jsonrpc: '2.0',\r\n                    id: + new Date(),\r\n                    method,\r\n                    params,\r\n                },\r\n                {\r\n                    headers: this._headers,\r\n                    transformResponse: function(response) { return jsonBig().parse(response) },\r\n                },\r\n            \r\n            ).then((response: any) => {\r\n                if (response?.error || response?.data?.error) {\r\n                    throw new JsonRpcProviderError(method, params, response?.error || response?.data?.error);\r\n\r\n                } else return response?.data?.result as T;\r\n            })\r\n    }\r\n    \r\n    /// ---------------------------------------------------------------------------------------------------------------\r\n   \r\n    /**\r\n     * Get the list of block hashes within given range, as known by the provider.\r\n     * @param {number} since - First epoch for which to return block hashes. If negative, return block hashes from the last n epochs.\r\n         * @param {number} limit - Number of block hashes to return. If negative, return the last n block hashes from this epoch range.\r\n     */\r\n    public async blocks(since: number = -1, limit: number = 1,): Promise<Array<[number, Hash]>> {\r\n        return this.callApiMethod<[Number, Hash]>(Methods.GetBlockChain, [since, limit, ]);\r\n    }\r\n    \r\n    /// Get consensus constants used by the node\r\n    public async constants(): Promise<ConsensusConstants> {\r\n        if (!this._constants) {\r\n            return this\r\n                .callApiMethod<ConsensusConstants>(Methods.GetConsensusConstants)\r\n                .then((constants: ConsensusConstants) => {\r\n                    this._constants = constants\r\n                    return constants\r\n                })\r\n        } else {\r\n            return this._constants\r\n        }    \r\n    }\r\n\r\n    /// Get limited list of currently top holders, as known by the provider.\r\n    public async holders(minBalance = 0, maxBalance?: number): Promise<Record<PublicKeyHashString, Balance2>> {\r\n        return this\r\n            .callApiMethod<Record<PublicKeyHashString, Balance>>(Methods.GetBalance2, {\r\n                all: {\r\n                    minBalance,\r\n                    ... maxBalance ? { maxBalance } : {}\r\n                }\r\n            }).then((balances: Record<PublicKeyHashString, Balance2>) => {\r\n                const reverseCompare = (a: Balance2, b: Balance2) => {\r\n                    const a_tot = a.locked + a.unlocked + a.staked\r\n                    const b_tot = b.locked + b.unlocked + b.staked\r\n                    if (a_tot < b_tot) return 1;\r\n                    else if (a_tot > b_tot) return -1;\r\n                    else return 0;\r\n                }\r\n                return Object.fromEntries(\r\n                    Object.entries(balances)\r\n                        .sort((a: (string | Balance2)[], b: (string | Balance2)[]) => reverseCompare(a[1] as Balance2, b[1] as Balance2))\r\n                );\r\n            })\r\n    }\r\n    \r\n    /// Get list of known peers\r\n    public async knownPeers(): Promise<Array<PeerAddr>> {\r\n        return this.callApiMethod<Array<PeerAddr>>(Methods.KnownPeers);\r\n    }\r\n    \r\n    /// Get all the pending transactions\r\n    public async mempool(): Promise<Mempool> {\r\n        return this.callApiMethod<Mempool>(Methods.GetMempool);\r\n    }    \r\n    \r\n    /// Get priority and time-to-block estimations for different priority tiers.\r\n    public async priorities(): Promise<Priorities> {\r\n        return this.callApiMethod<Priorities>(Methods.Priority)\r\n    }\r\n    \r\n    /// Get information about protocol versions and which version is currently being enforced.\r\n    public async protocolInfo(): Promise<ProtocolInfo> {\r\n        return this.callApiMethod<ProtocolInfo>(Methods.Protocol)\r\n    }\r\n    \r\n    /// Get a full list of staking powers ordered by rank\r\n    public async powers(query?: QueryStakingPowers): Promise<Array<StakingPower>> {\r\n        return this.callApiMethod<Array<StakingPower>>(Methods.QueryStakingPowers, query)\r\n    }\r\n    \r\n    /// Get a full list of current stake entries  Query the amount of nanowits staked by an address.\r\n    public async stakes(query?: QueryStakes): Promise<Array<StakeEntry>> {\r\n        return this\r\n            .callApiMethod<Array<StakeEntry>>(Methods.QueryStakes, query)\r\n            .catch(err => {\r\n                if (err?.error?.message && err.error.message.indexOf(\"not registered\") > -1) {\r\n                    return []\r\n                } else {\r\n                    throw err\r\n                }\r\n            })\r\n    }\r\n    \r\n    /// Get node status\r\n    public async syncStatus(): Promise<SyncStatus> {\r\n        return this.callApiMethod<SyncStatus>(Methods.SyncStatus);\r\n    }\r\n    \r\n    public async wips(): Promise<SignalingInfo> {\r\n        return this.callApiMethod<SignalingInfo>(Methods.SignalingInfo)\r\n    }\r\n\r\n    public async witnesses(_since?: number): Promise<number> {\r\n        // todo: witnesses estimation should instead be computed in proportion to\r\n        //       ratio of validators that have honestly witnessed data requests\r\n        //       vs validators that have honestly witnessed data requests and\r\n        //       never revealed \"i passed\" out of majority, \r\n        //       within the specified range of epochs.\r\n        let census = 0\r\n        return this \r\n            .stakes({ params: { distinct: true }}) // todo: implement `count` flag on IJsonRpcProvider.stakes()\r\n            .then(records => {\r\n                census = records.length\r\n                return this.blocks(-16, 16) // todo: blocks() should return epoch, hash and validator pkh for each block\r\n            })\r\n            .then(records => {\r\n                return Promise.all(records.map(record => this.getBlock(record[1])))\r\n            })\r\n            .then(blocks => {\r\n                const validators: Array<PublicKeyHashString> = []\r\n                blocks.map(block => {\r\n                    const pkh = PublicKey.fromProtobuf(block.block_sig.public_key).hash().toBech32(this.network)\r\n                    if (!validators.includes(pkh)) validators.push(pkh);\r\n                })\r\n                return Math.min(\r\n                    validators.length,\r\n                    Math.floor(this.network === \"testnet\" ? census / 2 : census / 4)\r\n                )\r\n            })\r\n    }\r\n    \r\n    /// ---------------------------------------------------------------------------------------------------------------\r\n    /// Get balance\r\n    public async getBalance(pkh: PublicKeyHashString): Promise<Balance2> {\r\n        return this\r\n            .callApiMethod<Balance2>(Methods.GetBalance2, { pkh })\r\n            .then((balance: Balance2) => ({\r\n                locked: BigInt(balance.locked),\r\n                staked: BigInt(balance.staked),\r\n                unlocked: BigInt(balance.unlocked),\r\n            }))\r\n    }\r\n    \r\n    /**\r\n     * Get block info by hash\r\n     * @param {Hash} blockHash - Hash of the block that we are querying.\r\n     * @param {boolean} showTransactionHash - Whether to include an extra field containing array of transaction hashes.\r\n     */\r\n    public async getBlock(\r\n            blockHash: Hash,\r\n            showTransactionHash = false,\r\n        ): Promise<Block>\r\n    {\r\n        return this.callApiMethod<Block>(Methods.GetBlock, [blockHash, showTransactionHash, ])\r\n    }\r\n    \r\n    public async getDataRequest(drTxHash: Hash): Promise<DataRequestReport> {\r\n        return this.callApiMethod<DataRequestReport>(Methods.DataRequestReport, [drTxHash, ])\r\n    }\r\n    \r\n    /// Get the blocks that pertain to the superblock index\r\n    public async getSuperblock(epoch: Epoch): Promise<SuperblockReport> {\r\n        return this.callApiMethod<SuperblockReport>(Methods.GetSuperblock, { \"block_epoch\": epoch });\r\n    }\r\n    \r\n    public async getTransaction(txHash: Hash): Promise<TransactionReport> {\r\n        return this.callApiMethod<TransactionReport>(Methods.GetTransaction, [txHash, ]);\r\n    }\r\n\r\n    public async getTransactionReceipt(txHash: Hash): Promise<TransactionReceipt> {\r\n        // todo: fetch/update receipt from provider, if not cached\r\n        return JsonRpcProvider.receipts[txHash]\r\n    }\r\n    \r\n    /// Get utxos\r\n    public async getUtxos(pkh: PublicKeyHashString, smallFirst = true): Promise<Array<UtxoMetadata>> {\r\n        return this\r\n            .callApiMethod<UtxoInfo>(Methods.GetUtxoInfo, [pkh, ])\r\n            .then((result: UtxoInfo) => {\r\n                const inversor = smallFirst ? 1 : -1\r\n                return result.utxos.sort((a, b) => {\r\n                    if (a.value > b.value) return inversor;\r\n                    else if (a.value < b.value) return - inversor;\r\n                    else return 0;\r\n                }).map((utxo: UtxoMetadata) => ({\r\n                    ...utxo,\r\n                    value: BigInt(utxo.value),\r\n                }))\r\n            })\r\n    }\r\n    \r\n    /// ---------------------------------------------------------------------------------------------------------------\r\n    public async sendRawTransaction(transaction: any): Promise<boolean> {\r\n        return this.callApiMethod<boolean>(Methods.Inventory, { transaction })\r\n    }\r\n\r\n    /// Get supply info\r\n    public async supplyInfo(): Promise<SupplyInfo> {\r\n        return this.callApiMethod<SupplyInfo>(Methods.GetSupplyInfo)\r\n    }\r\n}"]}

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

@@ -0,0 +1,18 @@
+import { IJsonRpcProvider, JsonRpcProvider } from "./provider";
+import { DataRequestReport, PeerAddr, SupplyInfo } from "./types";
+import { Hash } from "../types";
+export interface IReporter extends IJsonRpcProvider {
+    providers(): Promise<Array<string>>;
+    supplyInfo(): Promise<SupplyInfo>;
+    getDataRequest(drTxHash: Hash, channel?: string): Promise<DataRequestReport>;
+    searchDataRequests(radHash: Hash): Promise<any>;
+}
+export declare class Reporter extends JsonRpcProvider implements IReporter {
+    constructor(url?: string);
+    peers(): Promise<Array<PeerAddr>>;
+    providers(): Promise<Array<string>>;
+    supplyInfo(): Promise<SupplyInfo>;
+    reportDataRequest(drTxHash: Hash, channel?: string): Promise<DataRequestReport>;
+    searchDataRequests(radHash: Hash): Promise<any>;
+}
+//# sourceMappingURL=reporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../../../src/lib/rpc/reporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAW,QAAQ,EAAE,UAAU,EAAG,MAAM,SAAS,CAAA;AAC3E,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE/B,MAAM,WAAW,SAAU,SAAQ,gBAAgB;IAC/C,SAAS,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IACnC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAElC,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;IAC5E,kBAAkB,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACnD;AAED,qBAAa,QAAS,SAAQ,eAAgB,YAAW,SAAS;gBAClD,GAAG,CAAC,EAAE,MAAM;IAKjB,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAI3B,SAAS,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAKnC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAKjC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI/E,kBAAkB,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC;CAG/D"}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reporter = void 0;
+const provider_1 = require("./provider");
+const types_1 = require("./types");
+class Reporter extends provider_1.JsonRpcProvider {
+    constructor(url) {
+        super(url || process.env.WITNET_TOOLKIT_REPORTER_URL || "https://kermit.witnet.io");
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    peers() {
+        return this.callApiMethod(types_1.Methods.KnownPeers);
+    }
+    async providers() {
+        return this.callApiMethod(types_1.Methods.Providers);
+    }
+    /// Get supply info
+    async supplyInfo() {
+        return this.callApiMethod(types_1.Methods.GetSupplyInfo);
+    }
+    /// ---------------------------------------------------------------------------------------------------------------
+    async reportDataRequest(drTxHash, channel) {
+        return this.callApiMethod(types_1.Methods.DataRequestReport, [drTxHash, channel,]);
+    }
+    async searchDataRequests(radHash) {
+        return this.callApiMethod(types_1.Methods.SearchDataRequests, [radHash,]);
+    }
+}
+exports.Reporter = Reporter;
+//# sourceMappingURL=data:application/json;base64,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