@witnet/sdk 1.0.0-beta.0

package/dist/src/lib/radon/index.js

@@ -0,0 +1,707 @@
+"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.types = exports.retrievals = exports.reducers = exports.filters = exports.RadonRetrieval = exports.RadonModal = exports.RadonTemplate = exports.RadonRequest = void 0;
+exports.RadonRequestFromAssets = RadonRequestFromAssets;
+exports.RadonScript = RadonScript;
+const cbor_1 = require("cbor");
+const graphql_query_compress_1 = __importDefault(require("graphql-query-compress"));
+const protoBuf = require("protobufjs").Root.fromJSON(require("../../../witnet/witnet.proto.json"));
+const RADRequest = protoBuf.lookupType("RADRequest");
+const helpers_1 = require("../../bin/helpers");
+const utils_1 = require("../crypto/utils");
+const utils_2 = require("./utils");
+const filters_1 = require("./filters");
+const reducers_1 = require("./reducers");
+const types_1 = require("./types");
+class RadonArtifact {
+    constructor(specs) {
+        if (!specs.sources || !Array.isArray(specs.sources) || specs.sources.length == 0) {
+            throw TypeError("RadonArtifact: cannot build if no retrievals are passed");
+        }
+        specs.sources?.forEach((retrieval, index) => {
+            if (retrieval === undefined) {
+                throw TypeError(`RadonArtifact: retrieval #${index} is undefined`);
+            }
+            else if (!(retrieval instanceof RadonRetrieval)) {
+                throw TypeError(`RadonArtifact: retrieval #${index}: invalid type`);
+            }
+        });
+        this.sources = specs.sources;
+        this.sourcesReducer = specs.sourcesReducer;
+        this.witnessReducer = specs.witnessReducer;
+    }
+    opsCount() {
+        return (this.sources?.map(retrieval => retrieval.opsCount()).reduce((sum, a) => sum + a) || 0)
+            + this.sourcesReducer?.opsCount()
+            + this.witnessReducer?.opsCount();
+    }
+}
+class RadonRequest extends RadonArtifact {
+    /**
+     * Decodes a RadonRequest artifact out from a Protobuf-serialized bytecode.
+     * @param bytecode Radon request bytecode.
+     * @returns RadonRequest object.
+     */
+    static fromBytecode(bytecode) {
+        let buffer;
+        if ((0, helpers_1.isHexString)(bytecode)) {
+            buffer = (0, helpers_1.fromHexString)(bytecode);
+        }
+        else if (bytecode instanceof Uint8Array) {
+            buffer = Buffer.from(bytecode);
+        }
+        else if (bytecode instanceof Buffer) {
+            buffer = bytecode;
+        }
+        else {
+            throw new TypeError(`RadonRequest: unsupported bytecode format: ${bytecode}`);
+        }
+        const obj = RADRequest.decode(buffer);
+        return RadonRequest.fromProtobuf(obj);
+    }
+    /**
+     * Decodes a RadonRequest artifact out from a Protobuf object.
+     * @param obj Protobuf object.
+     * @returns RadonRequest object.
+     */
+    static fromProtobuf(obj) {
+        const sources = obj.retrieve.map((retrieval) => {
+            const specs = {};
+            if (retrieval?.url) {
+                specs.url = retrieval.url;
+            }
+            if (retrieval?.headers) {
+                specs.headers = Object.fromEntries(retrieval.headers.map((stringPair) => [
+                    stringPair.left,
+                    stringPair.right
+                ]));
+            }
+            if (retrieval?.body && retrieval.body.length > 0) {
+                specs.body = (0, helpers_1.utf8ArrayToStr)(Object.values(retrieval.body));
+            }
+            if (retrieval?.script)
+                specs.script = (0, utils_2.parseRadonScript)((0, helpers_1.toHexString)(retrieval.script));
+            specs.method = retrieval.kind;
+            return new RadonRetrieval(specs);
+        });
+        const decodeFilter = (f) => {
+            if (f?.args && f.args.length > 0)
+                return new filters_1.RadonFilter(f.op, (0, cbor_1.decode)(Uint8Array.from(f.args)));
+            else
+                return new filters_1.RadonFilter(f.op);
+        };
+        return new RadonRequest({
+            sources,
+            sourcesReducer: new reducers_1.RadonReducer(obj.aggregate.reducer, obj.aggregate.filters?.map(decodeFilter)),
+            witnessReducer: new reducers_1.RadonReducer(obj.tally.reducer, obj.tally.filters?.map(decodeFilter))
+        });
+    }
+    constructor(specs) {
+        const sources = Array.isArray(specs.sources) ? specs.sources : [specs.sources];
+        super({
+            sources,
+            sourcesReducer: specs?.sourcesReducer || reducers.Mode(),
+            witnessReducer: specs?.witnessReducer || reducers.Mode(),
+        });
+        let argsCount = sources.map(retrieval => retrieval.argsCount).reduce((prev, curr) => prev + curr);
+        if (argsCount > 0) {
+            throw TypeError("RadonRequest: parameterized retrievals were passed");
+        }
+    }
+    _encode() {
+        const payload = this.toProtobuf();
+        const errMsg = RADRequest.verify(payload);
+        if (errMsg) {
+            throw Error(errMsg);
+        }
+        else {
+            const message = RADRequest.fromObject(payload);
+            return RADRequest.encode(message).finish();
+        }
+    }
+    async execDryRun() {
+        return (await (0, helpers_1.execRadonBytecode)(this.toBytecode(), '--json')).trim();
+    }
+    get radHash() {
+        return (0, helpers_1.toHexString)((0, utils_1.sha256)(this._encode()), false);
+    }
+    toBytecode() {
+        return (0, helpers_1.toHexString)(this._encode()); //encodeRADRequest(this.toProtobuf()), true)
+    }
+    toJSON(humanize) {
+        return {
+            retrieve: this.sources.map(retrieval => retrieval.toJSON(humanize)),
+            aggregate: this.sourcesReducer.toJSON(humanize),
+            tally: this.witnessReducer.toJSON(humanize),
+            ...(humanize ? {} : { time_lock: 0 }),
+        };
+    }
+    toProtobuf() {
+        return {
+            //timeLock: 0,
+            retrieve: this.sources.map(retrieval => retrieval.toProtobuf()),
+            aggregate: this.sourcesReducer.toProtobuf(),
+            tally: this.witnessReducer.toProtobuf(),
+        };
+    }
+    weight() {
+        return this.toBytecode().slice(2).length / 2;
+    }
+}
+exports.RadonRequest = RadonRequest;
+function RadonRequestFromAssets(specs) {
+    const sources = [];
+    const dict = retrievals.fromRadonAssets(specs.assets);
+    // const args: string[][] = []
+    Object.keys(specs.argsMap).forEach(key => {
+        const retrieval = dict[key];
+        const args = specs.argsMap[key];
+        if (retrieval.argsCount > 0) {
+            if (!args || args.length < retrieval.argsCount) {
+                throw TypeError(`Insufficient args passed to retrieval named as '${key}': ${args.length} < ${retrieval.argsCount}`);
+            }
+            else {
+                sources.push(retrieval.foldArgs(args));
+            }
+        }
+        else {
+            sources.push(retrieval);
+        }
+    });
+    return new RadonRequest({ sources, sourcesReducer: specs?.sourcesReducer, witnessReducer: specs?.witnessReducer });
+}
+;
+function RadonScript(inputType) {
+    if (!inputType)
+        throw TypeError("Input Radon data type must be specified when declaring a new Radon script.");
+    return new inputType();
+}
+class RadonTemplate extends RadonArtifact {
+    constructor(specs, samples) {
+        const sources = Array.isArray(specs.sources) ? specs.sources : [specs.sources];
+        super({
+            sources,
+            sourcesReducer: specs?.sourcesReducer || reducers.Mode(),
+            witnessReducer: specs?.witnessReducer || reducers.Mode(),
+        });
+        this._argsCount = sources.map(retrieval => retrieval?.argsCount).reduce((prev, curr) => Math.max(prev, curr), 0);
+        if (this._argsCount == 0) {
+            throw TypeError("RadonTemplate: no parameterized retrievals were passed");
+        }
+        this.homogeneous = !sources.find(retrieval => retrieval.argsCount !== this._argsCount);
+        if (samples) {
+            Object.keys(samples).forEach(sample => {
+                let sampleArgs = Object(samples)[sample];
+                if (typeof sampleArgs === "string") {
+                    sampleArgs = [sampleArgs];
+                }
+                if (sampleArgs.length > 0) {
+                    if (!Array.isArray(sampleArgs[0])) {
+                        Object(samples)[sample] = Array(sources.length).fill(sampleArgs);
+                        sampleArgs = Object(samples)[sample];
+                    }
+                    else if (sampleArgs?.length != sources.length) {
+                        throw TypeError(`RadonTemplate: arguments mismatch in sample "${sample}": ${sampleArgs?.length} samples given vs. ${sources.length} expected`);
+                    }
+                    sampleArgs?.forEach((subargs, index) => {
+                        if (subargs.length < sources[index].argsCount) {
+                            throw TypeError(`\x1b[1;33mRadonRequestTemplate: arguments mismatch in test \x1b[1;31m'${sample}'\x1b[1;33m: \x1b[1;37mRetrieval #${index}\x1b[1;33m: ${subargs?.length} parameters given vs. ${sources[index].argsCount} expected\x1b[0m`);
+                        }
+                    });
+                }
+            });
+            this.samples = samples;
+        }
+    }
+    get argsCount() {
+        return this._argsCount;
+    }
+    buildRadonRequest(args) {
+        const sources = [];
+        if (this.homogeneous) {
+            // args can be either any, string[] or string[0][] 
+            if (Array.isArray(args) && args[0] && Array.isArray(args[0])) {
+                if (args.length > 1) {
+                    throw new TypeError(`RadonTemplate: homogeneous template: args vector dimension ${args.length} > 1.`);
+                }
+                args = args[0];
+            }
+            else if (Array.isArray(args) && args.length !== this.argsCount) {
+                throw new TypeError(`RadonTemplate: homogenous template: missing ${this.argsCount - args.length} out of ${args.length} parameters.`);
+            }
+            this.sources.forEach(retrieval => sources.push(retrieval.foldArgs(args)));
+        }
+        else {
+            if (!Array.isArray(args) || args.length !== this.sources.length) {
+                throw new TypeError(`RadonTemplate: args vector dimension ${args.length} != ${this.sources.length}`);
+            }
+            this.sources.forEach((retrieval, index) => {
+                if (Array.isArray(args[index]) && retrieval.argsCount !== args[index].length) {
+                    throw new TypeError(`RadonTemplate: retrieval #${index + 1}: mismatching args count: ${args[index].length} != ${retrieval.argsCount} ([${args[index]})]`);
+                }
+                sources.push(retrieval.foldArgs(args[index]));
+            });
+        }
+        return new RadonRequest({
+            sources,
+            sourcesReducer: this.sourcesReducer,
+            witnessReducer: this.witnessReducer,
+        });
+    }
+}
+exports.RadonTemplate = RadonTemplate;
+class RadonModal extends RadonTemplate {
+    constructor(specs) {
+        if (!specs.retrieval.isModal()) {
+            throw TypeError("RadonModal: no modal retrieval was passed.");
+        }
+        super({
+            sources: [specs.retrieval],
+            sourcesReducer: specs?.sourcesReducer || reducers.Mode(),
+            witnessReducer: specs?.witnessReducer || reducers.Mode(),
+        }, specs.retrieval?.samples);
+        if (specs?.providers) {
+            this._providers = this._checkProviders(specs.providers);
+        }
+        else {
+            this._providers = [];
+        }
+    }
+    get argsCount() {
+        return this._argsCount - 1;
+    }
+    get providers() {
+        return this._providers;
+    }
+    set providers(providers) {
+        this._providers = this._checkProviders(providers);
+    }
+    buildRadonRequest(args) {
+        if (this.argsCount > 0) {
+            return this.buildRadonTemplate(this.providers).buildRadonRequest(args);
+        }
+        else if (this.providers.length === 0) {
+            throw new TypeError(`RadonModal: no providers were previously settled.`);
+        }
+        return new RadonRequest({
+            sources: this.sources[0].spawnRetrievals(...this.providers),
+            sourcesReducer: this.sourcesReducer,
+            witnessReducer: this.witnessReducer,
+        });
+    }
+    buildRadonTemplate(providers) {
+        if (!providers) {
+            providers = this._checkProviders([...this._providers]);
+        }
+        else {
+            providers = this._checkProviders([...providers]);
+        }
+        if (!providers || providers.length === 0) {
+            throw new TypeError(`RadonModal: no providers were specified.`);
+        }
+        return new RadonTemplate({
+            sources: this.sources[0].spawnRetrievals(...providers),
+            sourcesReducer: this.sourcesReducer,
+            witnessReducer: this.witnessReducer,
+        });
+    }
+    _checkProviders(providers) {
+        providers.forEach(provider => {
+            const [schema,] = (0, helpers_1.parseURL)(provider);
+            if (!schema.startsWith("http://") && !schema.startsWith("https://")) {
+                throw TypeError(`RadonModal: invalid provider: ${provider}`);
+            }
+        });
+        return providers;
+    }
+}
+exports.RadonModal = RadonModal;
+class RadonRetrieval {
+    constructor(specs, samples) {
+        if (specs.method === retrievals.Methods.RNG && (specs?.url || specs?.headers?.size || specs?.body)) {
+            throw TypeError("RadonRetrieval: RNG accepts no URLs or headers");
+            // } else if (!specs?.url && (method == Methods.HttpPost || method == Methods.HttpGet)) {
+            //     throw TypeError("RadonRetrieval: URL must be specified");
+        }
+        else if (specs?.body && specs.method == retrievals.Methods.HttpGet) {
+            throw TypeError("RadonRetrieval: body cannot be specified in HTTP-GET queries");
+        }
+        this.method = specs.method;
+        if (specs?.url) {
+            this.url = specs.url;
+            if (!(0, helpers_1.isWildcard)(specs.url)) {
+                try {
+                    let parts = (0, helpers_1.parseURL)(specs.url);
+                    this.schema = parts[0];
+                    if (parts[1] !== "")
+                        this.authority = parts[1];
+                    if (parts[2] !== "")
+                        this.path = parts[2];
+                    if (parts[3] !== "")
+                        this.query = parts[3];
+                }
+                catch { }
+            }
+        }
+        else if (specs.method === retrievals.Methods.HttpGet
+            || specs.method === retrievals.Methods.HttpPost
+            || specs.method === retrievals.Methods.HttpHead) {
+            this.url = "\\0\\";
+        }
+        if (specs?.headers) {
+            if (typeof specs.headers !== 'object' || Array.isArray(specs.headers)) {
+                throw new TypeError("RadonRetrieval: HTTP headers must be of type Record<string, string>");
+            }
+            this.headers = specs?.headers;
+        }
+        this.body = specs?.body;
+        if (specs?.script)
+            this.script = new types_1.RadonScript(specs?.script);
+        this.argsCount = Math.max((0, helpers_1.getWildcardsCountFromString)(this?.url), (0, helpers_1.getWildcardsCountFromString)(this?.body), ...Object.keys(this?.headers || {}).map(key => (0, helpers_1.getWildcardsCountFromString)(key)) ?? [], ...Object.values(this?.headers || {}).map(value => (0, helpers_1.getWildcardsCountFromString)(value)) ?? [], this.script?.argsCount() || 0);
+        if (samples && this.argsCount === 0) {
+            throw new TypeError("RadonRetrieval: passed samples to non-parameterized retrieval.");
+        }
+        this.samples = samples;
+        if (specs?.argsKeys) {
+            if (this.argsCount === 0) {
+                throw new TypeError("RadonRetrieval: passed args keys to non-parameterized retrieval");
+            }
+            else if (specs.argsKeys.length !== this.argsCount) {
+                throw new TypeError(`RadonRetrieval: passed invalid number of args keys: ${specs.argsKeys.length} != ${this.argsCount}`);
+            }
+            this.argsKeys = specs.argsKeys;
+        }
+    }
+    isModal() {
+        return !this.url || this.url === "\\0\\";
+    }
+    isParameterized() {
+        return this.argsCount > 0;
+    }
+    /**
+     * Creates a new Radon Retrieval by orderly replacing indexed wildcards with given parameters.
+     * Fails if not parameterized, of if passing too many parameters.
+     */
+    foldArgs(args) {
+        if (this.argsCount === 0) {
+            throw new TypeError(`RadonRetrieval: cannot fold unparameterized retrieval`);
+        }
+        const params = [];
+        if (Array.isArray(args)) {
+            if (args.length > this.argsCount) {
+                throw new TypeError(`RadonRetrieval: too may args passed: ${args.length} > ${this.argsCount}`);
+            }
+            params.push(...args);
+        }
+        else if (typeof args === 'object') {
+            if (!this.argsKeys) {
+                throw new TypeError(`RadonRetrieval: unexpected args map: undefined args keys.`);
+            }
+            else {
+                this.argsKeys.forEach(key => {
+                    if (!args[key]) {
+                        throw new TypeError(`RadonRetrieval: missing value for parameter "${key}".`);
+                    }
+                    params.push(args[key]);
+                });
+            }
+        }
+        else {
+            params.push(args);
+        }
+        return new RadonRetrieval({
+            method: this.method,
+            url: (0, helpers_1.replaceWildcards)(this.url, params),
+            body: (0, helpers_1.replaceWildcards)(this.body, params),
+            headers: Object.fromEntries(Object.entries(this.headers || {}).map(([key, value]) => [
+                (0, helpers_1.replaceWildcards)(key, params),
+                (0, helpers_1.replaceWildcards)(value, params),
+            ])),
+            script: this.script?.replaceWildcards(...params),
+        });
+    }
+    /**
+     * Creates one or more clones of this retrieval, in which the index-0 wildcard
+     * will be replaced by the given values. Fails if the retrieval is not parameterized.
+     */
+    spawnRetrievals(...values) {
+        const _spawned = [];
+        if (this.argsCount == 0) {
+            throw new TypeError(`RadonRetrieval: cannot spawn from unparameterized retrieval`);
+        }
+        values.forEach(value => {
+            _spawned.push(new RadonRetrieval({
+                method: this.method,
+                url: (0, helpers_1.spliceWildcard)(this.url, 0, value, this.argsCount),
+                body: (0, helpers_1.spliceWildcard)(this.body, 0, value, this.argsCount),
+                headers: Object.fromEntries(Object.entries(this.headers || {}).map(([headerKey, headerValue]) => [
+                    (0, helpers_1.spliceWildcard)(headerKey, 0, value, this.argsCount),
+                    (0, helpers_1.spliceWildcard)(headerValue, 0, value, this.argsCount),
+                ])),
+                script: this.script?.spliceWildcard(0, value),
+                argsKeys: this.argsKeys?.slice(1),
+            }));
+        });
+        return _spawned;
+    }
+    toJSON(humanize) {
+        const kind = ["", "HTTP-GET", "RNG", "HTTP-POST", "HTTP-HEAD"];
+        let json = {
+            kind: kind[this.method] // humanize ? Methods[this.method] : this.method,
+        };
+        if (this.url)
+            json.url = this.url;
+        if (this.headers) {
+            json.headers = Object.entries(this.headers);
+        }
+        if (this.body)
+            json.body = this.body;
+        json.script = humanize ? this.script?.toString() : Array.from((0, helpers_1.fromHexString)(this.script?.toBytecode() || '0x80'));
+        return json;
+    }
+    toProtobuf() {
+        let protobuf = {
+            kind: this.method,
+        };
+        if (this.url)
+            protobuf.url = this.url;
+        if (this.headers) {
+            protobuf.headers = Object.entries(this.headers).map(([headerKey, headerValue]) => {
+                return {
+                    left: headerKey,
+                    right: headerValue,
+                };
+            });
+        }
+        if (this.body) {
+            const utf8Array = (0, helpers_1.toUtf8Array)(this.body);
+            protobuf.body = utf8Array;
+        }
+        protobuf.script = Object.values(Uint8Array.from((0, cbor_1.encode)(this.script?.encode() || [])));
+        return protobuf;
+    }
+    opsCount() {
+        return this._countOps(this.script?.encode() || []);
+    }
+    _countOps(items) {
+        return items.length > 0 ? items.map(item => Array.isArray(item) ? this._countOps(item) : 1).reduce((sum, a) => sum + a) : 0;
+    }
+}
+exports.RadonRetrieval = RadonRetrieval;
+var filters;
+(function (filters) {
+    filters.Opcodes = filters_1.Opcodes;
+    filters.Class = filters_1.RadonFilter;
+    function Mode() { return new filters_1.RadonFilter(filters_1.Opcodes.Mode); }
+    filters.Mode = Mode;
+    function Stdev(stdev) { return new filters_1.RadonFilter(filters_1.Opcodes.StandardDeviation, stdev); }
+    filters.Stdev = Stdev;
+})(filters || (exports.filters = filters = {}));
+var reducers;
+(function (reducers) {
+    reducers.Opcodes = reducers_1.Opcodes;
+    reducers.Class = reducers_1.RadonReducer;
+    function Mode(...filters) { return new reducers_1.RadonReducer(reducers_1.Opcodes.Mode, filters); }
+    reducers.Mode = Mode;
+    function Mean(...filters) { return new reducers_1.RadonReducer(reducers_1.Opcodes.MeanAverage, filters); }
+    reducers.Mean = Mean;
+    function Median(...filters) { return new reducers_1.RadonReducer(reducers_1.Opcodes.MedianAverage, filters); }
+    reducers.Median = Median;
+    function Stdev(...filters) { return new reducers_1.RadonReducer(reducers_1.Opcodes.StandardDeviation, filters); }
+    reducers.Stdev = Stdev;
+    function ConcatHash(...filters) { return new reducers_1.RadonReducer(reducers_1.Opcodes.ConcatenateAndHash, filters); }
+    reducers.ConcatHash = ConcatHash;
+    function PriceAggregate() { return new reducers_1.RadonReducer(reducers_1.Opcodes.MeanAverage, [filters.Stdev(1.4)]); }
+    reducers.PriceAggregate = PriceAggregate;
+    function PriceTally() { return new reducers_1.RadonReducer(reducers_1.Opcodes.MeanAverage, [filters.Stdev(2.5)]); }
+    reducers.PriceTally = PriceTally;
+})(reducers || (exports.reducers = reducers = {}));
+const ccdr = __importStar(require("./ccdr"));
+var retrievals;
+(function (retrievals) {
+    retrievals.rpc = ccdr;
+    function fromRadonAssets(assets) {
+        return new Proxy(assets, proxyHandler(RadonRetrieval));
+    }
+    retrievals.fromRadonAssets = fromRadonAssets;
+    let Methods;
+    (function (Methods) {
+        Methods[Methods["None"] = 0] = "None";
+        Methods[Methods["HttpGet"] = 1] = "HttpGet";
+        Methods[Methods["HttpHead"] = 4] = "HttpHead";
+        Methods[Methods["HttpPost"] = 3] = "HttpPost";
+        Methods[Methods["RNG"] = 2] = "RNG";
+    })(Methods = retrievals.Methods || (retrievals.Methods = {}));
+    /**
+     * Creates a Witnet randomness data source object.
+     * @param script (Optional) Radon Script to apply to the random seed proposed by every single witness,
+     * before aggregation.
+    **/
+    function RNG(script) {
+        const retrieval = new RadonRetrieval({ method: Methods.RNG, script });
+        if (retrieval?.script && retrieval?.script?.inputType?.constructor.name !== "RadonBytes") {
+            throw new TypeError("RNG scripts require [RadonBytes] as input type");
+        }
+        return retrieval;
+    }
+    retrievals.RNG = RNG;
+    ;
+    /**
+     * Creates a HTTP/GET data retrieval object.
+     * @param specs Radon Retrieval specs.
+    **/
+    function HttpGet(specs) {
+        return new RadonRetrieval({
+            method: Methods.HttpGet,
+            url: specs?.url,
+            headers: specs?.headers,
+            script: specs?.script,
+            argsKeys: specs?.argsKeys,
+        }, specs?.samples);
+    }
+    retrievals.HttpGet = HttpGet;
+    ;
+    /**
+     * Creates a HTTP/HEAD data retrieval object.
+     * @param specs Radon Retrieval specs.
+    **/
+    function HttpHead(specs) {
+        return new RadonRetrieval({
+            method: Methods.HttpHead,
+            url: specs?.url,
+            headers: specs?.headers,
+            script: specs?.script,
+            argsKeys: specs?.argsKeys,
+        }, specs?.samples);
+    }
+    retrievals.HttpHead = HttpHead;
+    ;
+    /**
+     * Creates a HTTP/POST data retrieval object.
+     * @param specs Radon Retrieval specs.
+    **/
+    function HttpPost(specs) {
+        return new RadonRetrieval({
+            method: Methods.HttpPost,
+            url: specs?.url,
+            headers: specs?.headers,
+            body: specs?.body,
+            script: specs?.script,
+            argsKeys: specs?.argsKeys,
+        }, specs?.samples);
+    }
+    retrievals.HttpPost = HttpPost;
+    ;
+    /**
+     * Creates a GraphQL-query data source object.
+     * @param specs Radon Retrieval specs.
+    **/
+    function GraphQLQuery(specs) {
+        return new RadonRetrieval({
+            method: Methods.HttpPost,
+            url: specs.url,
+            body: `{\"query\":\"${(0, graphql_query_compress_1.default)(specs.query).replaceAll('"', '\\"')}\"}`,
+            headers: { "Content-Type": "application/json;charset=UTF-8" },
+            script: specs?.script,
+            argsKeys: specs?.argsKeys,
+        }, specs?.samples);
+    }
+    retrievals.GraphQLQuery = GraphQLQuery;
+    ;
+    /**
+     * Creates a JSON-RPC data retrieval object.
+     * @param specs Radon Retrieval specs.
+    **/
+    function JsonRPC(specs) {
+        return new RadonRetrieval({
+            method: retrievals.Methods.HttpPost,
+            url: "\\0\\",
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                method: specs.rpc.method,
+                params: specs.rpc?.params,
+                id: 1,
+            }).replaceAll('\\\\', '\\'),
+            headers: { "Content-Type": "application/json;charset=UTF-8" },
+            script: specs?.script,
+            argsKeys: specs?.argsKeys,
+        }, specs?.samples);
+    }
+    retrievals.JsonRPC = JsonRPC;
+})(retrievals || (exports.retrievals = retrievals = {}));
+var types;
+(function (types) {
+    types.RadonArray = types_1.RadonArray;
+    types.RadonBoolean = types_1.RadonBoolean;
+    types.RadonBytes = types_1.RadonBytes;
+    types.RadonFloat = types_1.RadonFloat;
+    types.RadonInteger = types_1.RadonInteger;
+    types.RadonMap = types_1.RadonMap;
+    types.RadonScript = types_1.RadonScript;
+    types.RadonString = types_1.RadonString;
+})(types || (exports.types = types = {}));
+function proxyHandler(t) {
+    return {
+        get(target, prop) {
+            let found = target[prop] ?? findKeyInObject(target, prop);
+            // if (!found) {
+            //     throw EvalError(`['${prop}'] was not found in dictionary`)
+            // } else 
+            if (found && !(found instanceof t)) {
+                throw TypeError(`['${prop}'] was found with type ${found?.constructor?.name} instead of ${t.name}!`);
+            }
+            return found;
+        }
+    };
+}
+function findKeyInObject(dict, tag) {
+    for (const key in dict) {
+        if (typeof dict[key] === 'object') {
+            if (key === tag) {
+                return dict[key];
+            }
+            else {
+                let found = findKeyInObject(dict[key], tag);
+                if (found)
+                    return found;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/radon/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  decode as cborDecode,\r\n  encode as cborEncode,\r\n} from 'cbor'\r\nimport graphQlCompress from 'graphql-query-compress'\r\n\r\nconst protoBuf = require(\"protobufjs\").Root.fromJSON(require(\"../../../witnet/witnet.proto.json\"))\r\nconst RADRequest = protoBuf.lookupType(\"RADRequest\")\r\n\r\nimport {\r\n  execRadonBytecode,\r\n  fromHexString,\r\n  getWildcardsCountFromString,\r\n  isHexString,\r\n  isWildcard,\r\n  parseURL,\r\n  replaceWildcards,\r\n  spliceWildcard,\r\n  toHexString,\r\n  toUtf8Array,\r\n  utf8ArrayToStr,\r\n} from \"../../bin/helpers\"\r\n\r\nimport { sha256 } from \"../crypto/utils\"\r\nimport { parseRadonScript } from \"./utils\"\r\nimport { Opcodes as Filters, RadonFilter } from './filters'\r\nimport { Opcodes as Reducers, RadonReducer } from './reducers'\r\nimport { RadonAny, RadonString, RadonOperator } from './types'\r\nimport {\r\n  RadonArray as _RadonArray,\r\n  RadonBoolean as _RadonBoolean,\r\n  RadonBytes as _RadonBytes,\r\n  RadonFloat as _RadonFloat,\r\n  RadonInteger as _RadonInteger,\r\n  RadonMap as _RadonMap,\r\n  RadonString as _RadonString,\r\n  RadonScript as _RadonScript,\r\n} from './types'\r\n\r\ntype Args = string[] | string[][];\r\n\r\nclass RadonArtifact {\r\n\r\n  public readonly sources: RadonRetrieval[];\r\n  public readonly sourcesReducer: RadonReducer;\r\n  public readonly witnessReducer: RadonReducer;\r\n\r\n  constructor(specs: {\r\n    sources: RadonRetrieval[],\r\n    sourcesReducer: RadonReducer,\r\n    witnessReducer: RadonReducer,\r\n  }) {\r\n    if (!specs.sources || !Array.isArray(specs.sources) || specs.sources.length == 0) {\r\n      throw TypeError(\"RadonArtifact: cannot build if no retrievals are passed\")\r\n    }\r\n    specs.sources?.forEach((retrieval, index) => {\r\n      if (retrieval === undefined) {\r\n        throw TypeError(`RadonArtifact: retrieval #${index} is undefined`)\r\n      } else if (!(retrieval instanceof RadonRetrieval)) {\r\n        throw TypeError(`RadonArtifact: retrieval #${index}: invalid type`)\r\n      }\r\n    })\r\n    this.sources = specs.sources;\r\n    this.sourcesReducer = specs.sourcesReducer;\r\n    this.witnessReducer = specs.witnessReducer;\r\n  }\r\n\r\n  public opsCount(): number {\r\n    return (this.sources?.map(retrieval => retrieval.opsCount()).reduce((sum, a) => sum + a) || 0)\r\n      + this.sourcesReducer?.opsCount()\r\n      + this.witnessReducer?.opsCount()\r\n  }\r\n}\r\n\r\nexport class RadonRequest extends RadonArtifact {\r\n\r\n  /**\r\n   * Decodes a RadonRequest artifact out from a Protobuf-serialized bytecode.\r\n   * @param bytecode Radon request bytecode.\r\n   * @returns RadonRequest object.\r\n   */\r\n  public static fromBytecode(bytecode: any) {\r\n    let buffer\r\n    if (isHexString(bytecode)) {\r\n      buffer = fromHexString(bytecode)\r\n    } else if (bytecode instanceof Uint8Array) {\r\n      buffer = Buffer.from(bytecode)\r\n    } else if (bytecode instanceof Buffer) {\r\n      buffer = bytecode\r\n    } else {\r\n      throw new TypeError(`RadonRequest: unsupported bytecode format: ${bytecode}`)\r\n    }\r\n    const obj: any = RADRequest.decode(buffer)\r\n    return RadonRequest.fromProtobuf(obj)\r\n  }\r\n\r\n  /**\r\n   * Decodes a RadonRequest artifact out from a Protobuf object.\r\n   * @param obj Protobuf object.\r\n   * @returns RadonRequest object.\r\n   */\r\n  public static fromProtobuf(obj: any) {\r\n    const sources = obj.retrieve.map((retrieval: any) => {\r\n      const specs: any = {}\r\n      if (retrieval?.url) { specs.url = retrieval.url }\r\n      if (retrieval?.headers) {\r\n        specs.headers = Object.fromEntries(retrieval.headers.map((stringPair: any) => [\r\n          stringPair.left,\r\n          stringPair.right\r\n        ]))\r\n      }\r\n      if (retrieval?.body && retrieval.body.length > 0) {\r\n        specs.body = utf8ArrayToStr(Object.values(retrieval.body))\r\n      }\r\n      if (retrieval?.script) specs.script = parseRadonScript(toHexString(retrieval.script))\r\n      specs.method = retrieval.kind\r\n      return new RadonRetrieval(specs)\r\n    })\r\n    const decodeFilter = (f: any) => {\r\n      if (f?.args && f.args.length > 0) return new RadonFilter(f.op, cborDecode(Uint8Array.from(f.args)))\r\n      else return new RadonFilter(f.op);\r\n    }\r\n    return new RadonRequest({\r\n      sources,\r\n      sourcesReducer: new RadonReducer(obj.aggregate.reducer, obj.aggregate.filters?.map(decodeFilter)),\r\n      witnessReducer: new RadonReducer(obj.tally.reducer, obj.tally.filters?.map(decodeFilter))\r\n    })\r\n  }\r\n\r\n  constructor(specs: {\r\n    sources: RadonRetrieval | RadonRetrieval[],\r\n    sourcesReducer?: RadonReducer,\r\n    witnessReducer?: RadonReducer,\r\n  }) {\r\n    const sources = Array.isArray(specs.sources) ? specs.sources as RadonRetrieval[] : [specs.sources]\r\n    super({\r\n      sources,\r\n      sourcesReducer: specs?.sourcesReducer || reducers.Mode(),\r\n      witnessReducer: specs?.witnessReducer || reducers.Mode(),\r\n    })\r\n    let argsCount = sources.map(retrieval => retrieval.argsCount).reduce((prev, curr) => prev + curr)\r\n    if (argsCount > 0) {\r\n      throw TypeError(\"RadonRequest: parameterized retrievals were passed\")\r\n    }\r\n  }\r\n\r\n  protected _encode(): Buffer {\r\n    const payload = this.toProtobuf()\r\n    const errMsg = RADRequest.verify(payload)\r\n    if (errMsg) {\r\n      throw Error(errMsg);\r\n    } else {\r\n      const message = RADRequest.fromObject(payload);\r\n      return RADRequest.encode(message).finish()\r\n    }\r\n  }\r\n\r\n  public async execDryRun(): Promise<string> {\r\n    return (await execRadonBytecode(this.toBytecode(), '--json')).trim()\r\n  }\r\n\r\n  public get radHash(): string {\r\n    return toHexString(sha256(this._encode()), false)\r\n  }\r\n\r\n  public toBytecode(): string {\r\n    return toHexString(this._encode())//encodeRADRequest(this.toProtobuf()), true)\r\n  }\r\n\r\n  public toJSON(humanize?: boolean): any {\r\n    return {\r\n      retrieve: this.sources.map(retrieval => retrieval.toJSON(humanize)),\r\n      aggregate: this.sourcesReducer.toJSON(humanize),\r\n      tally: this.witnessReducer.toJSON(humanize),\r\n      ...(humanize ? {} : { time_lock: 0 }),\r\n    }\r\n  }\r\n\r\n  public toProtobuf(): any {\r\n    return {\r\n      //timeLock: 0,\r\n      retrieve: this.sources.map(retrieval => retrieval.toProtobuf()),\r\n      aggregate: this.sourcesReducer.toProtobuf(),\r\n      tally: this.witnessReducer.toProtobuf(),\r\n    }\r\n  }\r\n\r\n  public weight(): number {\r\n    return this.toBytecode().slice(2).length / 2;\r\n  }\r\n}\r\n\r\nexport function RadonRequestFromAssets(specs: {\r\n  assets: Object,\r\n  argsMap: Record<string, any | string[] | undefined>, \r\n  sourcesReducer?: RadonReducer,\r\n  witnessReducer?: RadonReducer,\r\n}): RadonRequest {\r\n  const sources: RadonRetrieval[] = []\r\n  const dict = retrievals.fromRadonAssets(specs.assets)\r\n  // const args: string[][] = []\r\n  Object.keys(specs.argsMap).forEach(key => {\r\n    const retrieval: RadonRetrieval = dict[key] \r\n    const args = (specs.argsMap as any)[key]\r\n    if (retrieval.argsCount > 0) {\r\n      if (!args || args.length < retrieval.argsCount) {\r\n        throw TypeError(`Insufficient args passed to retrieval named as '${key}': ${args.length} < ${retrieval.argsCount}`)\r\n      } else {\r\n        sources.push(retrieval.foldArgs(args))\r\n      }\r\n    } else {\r\n      sources.push(retrieval)\r\n    }\r\n  })\r\n  return new RadonRequest({ sources, sourcesReducer: specs?.sourcesReducer, witnessReducer: specs?.witnessReducer })\r\n};\r\n\r\nexport function RadonScript<InputType extends RadonAny = RadonString>(inputType: { new(ops?: RadonOperator): InputType; }): InputType {\r\n  if (!inputType) throw TypeError(\"Input Radon data type must be specified when declaring a new Radon script.\")\r\n  return new inputType();\r\n}\r\n\r\nexport class RadonTemplate extends RadonArtifact {\r\n\r\n  protected _argsCount: number;\r\n  \r\n  public readonly homogeneous: boolean;\r\n  public readonly samples?: Record<string, Args>;\r\n\r\n  constructor(\r\n    specs: {\r\n      sources: RadonRetrieval | RadonRetrieval[],\r\n      sourcesReducer?: RadonReducer,\r\n      witnessReducer?: RadonReducer,\r\n    },\r\n    samples?: Record<string, Args>\r\n  ) {\r\n    const sources = Array.isArray(specs.sources) ? specs.sources as RadonRetrieval[] : [specs.sources]\r\n    super({\r\n      sources,\r\n      sourcesReducer: specs?.sourcesReducer || reducers.Mode(),\r\n      witnessReducer: specs?.witnessReducer || reducers.Mode(),\r\n    })\r\n    this._argsCount = sources.map(retrieval => retrieval?.argsCount).reduce((prev, curr) => Math.max(prev, curr), 0)\r\n    if (this._argsCount == 0) {\r\n      throw TypeError(\"RadonTemplate: no parameterized retrievals were passed\")\r\n    }\r\n    this.homogeneous = !sources.find(retrieval => retrieval.argsCount !== this._argsCount)\r\n    if (samples) {\r\n      Object.keys(samples).forEach(sample => {\r\n        let sampleArgs: Args = Object(samples)[sample]\r\n        if (typeof sampleArgs === \"string\") {\r\n          sampleArgs = [sampleArgs]\r\n        }\r\n        if (sampleArgs.length > 0) {\r\n          if (!Array.isArray(sampleArgs[0])) {\r\n            Object(samples)[sample] = Array(sources.length).fill(sampleArgs)\r\n            sampleArgs = Object(samples)[sample]\r\n          } else if (sampleArgs?.length != sources.length) {\r\n            throw TypeError(`RadonTemplate: arguments mismatch in sample \"${sample}\": ${sampleArgs?.length} samples given vs. ${sources.length} expected`)\r\n          }\r\n          sampleArgs?.forEach((subargs, index) => {\r\n            if (subargs.length < sources[index].argsCount) {\r\n              throw TypeError(`\\x1b[1;33mRadonRequestTemplate: arguments mismatch in test \\x1b[1;31m'${sample}'\\x1b[1;33m: \\x1b[1;37mRetrieval #${index}\\x1b[1;33m: ${subargs?.length} parameters given vs. ${sources[index].argsCount} expected\\x1b[0m`)\r\n            }\r\n          })\r\n        }\r\n      })\r\n      this.samples = samples\r\n    }\r\n  }\r\n\r\n  public get argsCount(): number {\r\n    return this._argsCount\r\n  }\r\n\r\n  public buildRadonRequest(args: any | any[] | string[] | string[][]): RadonRequest {\r\n    const sources: RadonRetrieval[] = []\r\n    if (this.homogeneous) {\r\n      // args can be either any, string[] or string[0][] \r\n      if (Array.isArray(args) && args[0] && Array.isArray(args[0])) {\r\n        if (args.length > 1)  {\r\n          throw new TypeError(`RadonTemplate: homogeneous template: args vector dimension ${args.length} > 1.`)\r\n        }\r\n        args = args[0]\r\n        \r\n      } else if (Array.isArray(args) && args.length !== this.argsCount) {\r\n        throw new TypeError(\r\n          `RadonTemplate: homogenous template: missing ${this.argsCount - args.length} out of ${args.length} parameters.`\r\n        );\r\n      }\r\n      this.sources.forEach(retrieval => sources.push(retrieval.foldArgs(args)))\r\n    \r\n    } else {\r\n      if (!Array.isArray(args) || args.length !== this.sources.length) {\r\n        throw new TypeError(`RadonTemplate: args vector dimension ${args.length} != ${this.sources.length}`)\r\n      }\r\n      this.sources.forEach((retrieval, index) => {\r\n        if (Array.isArray(args[index]) && retrieval.argsCount !== args[index].length) {\r\n          throw new TypeError(\r\n            `RadonTemplate: retrieval #${\r\n              index + 1\r\n            }: mismatching args count: ${\r\n              args[index].length\r\n            } != ${\r\n              retrieval.argsCount\r\n            } ([${args[index]})]`\r\n          );\r\n        }\r\n        sources.push(retrieval.foldArgs(args[index]))\r\n      })\r\n    }\r\n    return new RadonRequest({\r\n      sources,\r\n      sourcesReducer: this.sourcesReducer,\r\n      witnessReducer: this.witnessReducer,\r\n    })\r\n  }\r\n}\r\n\r\nexport class RadonModal extends RadonTemplate {\r\n\r\n  protected _providers: Array<string>;\r\n\r\n  constructor(specs: {\r\n    providers?: Array<string>,\r\n    retrieval: RadonRetrieval,\r\n    sourcesReducer?: RadonReducer,\r\n    witnessReducer?: RadonReducer,\r\n  }) {\r\n    if (!specs.retrieval.isModal()) {\r\n      throw TypeError(\"RadonModal: no modal retrieval was passed.\")\r\n    }\r\n    super(\r\n      {\r\n        sources: [specs.retrieval],\r\n        sourcesReducer: specs?.sourcesReducer || reducers.Mode(),\r\n        witnessReducer: specs?.witnessReducer || reducers.Mode(),\r\n      }, \r\n      specs.retrieval?.samples\r\n    )\r\n    if (specs?.providers) {\r\n      this._providers = this._checkProviders(specs.providers)\r\n    } else {\r\n      this._providers = []\r\n    }\r\n  }\r\n\r\n  public get argsCount(): number {\r\n    return this._argsCount - 1;\r\n  }\r\n\r\n  public get providers(): Array<string> {\r\n    return this._providers\r\n  }\r\n\r\n  public set providers(providers: Array<string>) {\r\n    this._providers = this._checkProviders(providers)\r\n  }\r\n\r\n  public buildRadonRequest(args?: any | string[]): RadonRequest {\r\n    if (this.argsCount > 0) {\r\n      return this.buildRadonTemplate(this.providers).buildRadonRequest(args)\r\n    } else if (this.providers.length === 0) {\r\n      throw new TypeError(`RadonModal: no providers were previously settled.`)\r\n    }\r\n    return new RadonRequest({\r\n      sources: this.sources[0].spawnRetrievals(...this.providers),\r\n      sourcesReducer: this.sourcesReducer,\r\n      witnessReducer: this.witnessReducer,\r\n    })\r\n  }\r\n\r\n  public buildRadonTemplate(providers?: Array<string>): RadonTemplate {\r\n    if (!providers) {\r\n      providers = this._checkProviders([ ...this._providers ])\r\n    } else {\r\n      providers = this._checkProviders([ ...providers ])\r\n    }\r\n    if (!providers || providers.length === 0) {\r\n      throw new TypeError(`RadonModal: no providers were specified.`)\r\n    } \r\n    return new RadonTemplate({\r\n      sources: this.sources[0].spawnRetrievals(...providers),\r\n      sourcesReducer: this.sourcesReducer,\r\n      witnessReducer: this.witnessReducer,\r\n    })\r\n  }\r\n\r\n  _checkProviders(providers: Array<string>): Array<string> {\r\n    providers.forEach(provider => {\r\n      const [schema,] = parseURL(provider)\r\n      if (!schema.startsWith(\"http://\") && !schema.startsWith(\"https://\")) {\r\n        throw TypeError(`RadonModal: invalid provider: ${provider}`)\r\n      }\r\n    })\r\n    return providers\r\n  }\r\n}\r\n\r\nexport class RadonRetrieval {\r\n\r\n  public readonly argsKeys?: Array<string>;\r\n  public readonly argsCount: number;\r\n  public readonly method: retrievals.Methods;\r\n  public readonly authority?: string;\r\n  public readonly body?: string;\r\n  public readonly headers?: Record<string, string>;\r\n  public readonly path?: string;\r\n  public readonly query?: string;\r\n  public readonly schema?: string;\r\n  public readonly script?: _RadonScript;\r\n  public readonly url?: string;\r\n\r\n  public readonly samples?: Record<string, string[]>;\r\n\r\n  constructor(\r\n    specs: {\r\n      method: retrievals.Methods,\r\n      url?: string,\r\n      headers?: Record<string, string>,\r\n      body?: any,\r\n      script?: RadonAny,\r\n      argsKeys?: Array<string>,\r\n    }, \r\n    samples?: Record<string, string[]>\r\n  ) {\r\n    if (specs.method === retrievals.Methods.RNG && (specs?.url || specs?.headers?.size || specs?.body)) {\r\n      throw TypeError(\"RadonRetrieval: RNG accepts no URLs or headers\");\r\n      // } else if (!specs?.url && (method == Methods.HttpPost || method == Methods.HttpGet)) {\r\n      //     throw TypeError(\"RadonRetrieval: URL must be specified\");\r\n    } else if (specs?.body && specs.method == retrievals.Methods.HttpGet) {\r\n      throw TypeError(\"RadonRetrieval: body cannot be specified in HTTP-GET queries\")\r\n    }\r\n    this.method = specs.method\r\n    if (specs?.url) {\r\n      this.url = specs.url\r\n      if (!isWildcard(specs.url)) {\r\n        try {\r\n          let parts = parseURL(specs.url)\r\n          this.schema = parts[0]\r\n          if (parts[1] !== \"\") this.authority = parts[1]\r\n          if (parts[2] !== \"\") this.path = parts[2]\r\n          if (parts[3] !== \"\") this.query = parts[3]\r\n        } catch { }\r\n      }\r\n    } else if (\r\n      specs.method === retrievals.Methods.HttpGet\r\n        || specs.method === retrievals.Methods.HttpPost \r\n        || specs.method === retrievals.Methods.HttpHead\r\n    ) {\r\n      this.url = \"\\\\0\\\\\"\r\n    }\r\n    if (specs?.headers) {\r\n      if (typeof specs.headers !== 'object' || Array.isArray(specs.headers)) {\r\n        throw new TypeError(\"RadonRetrieval: HTTP headers must be of type Record<string, string>\")\r\n      }\r\n      this.headers = specs?.headers\r\n    }\r\n    this.body = specs?.body\r\n    if (specs?.script) this.script = new _RadonScript(specs?.script)\r\n    this.argsCount = Math.max(\r\n      getWildcardsCountFromString(this?.url),\r\n      getWildcardsCountFromString(this?.body),\r\n      ...Object.keys(this?.headers || {}).map(key => getWildcardsCountFromString(key)) ?? [],\r\n      ...Object.values(this?.headers || {}).map(value => getWildcardsCountFromString(value)) ?? [],\r\n      this.script?.argsCount() || 0,\r\n    )\r\n    if (samples && this.argsCount === 0) {\r\n      throw new TypeError(\"RadonRetrieval: passed samples to non-parameterized retrieval.\")\r\n    }\r\n    this.samples = samples\r\n    if (specs?.argsKeys) {\r\n      if (this.argsCount === 0) {\r\n        throw new TypeError(\"RadonRetrieval: passed args keys to non-parameterized retrieval\")\r\n      } else if (specs.argsKeys.length !== this.argsCount) {\r\n        throw new TypeError(`RadonRetrieval: passed invalid number of args keys: ${specs.argsKeys.length} != ${this.argsCount}`)\r\n      }\r\n      this.argsKeys = specs.argsKeys\r\n    }\r\n  }\r\n\r\n  public isModal(): boolean {\r\n    return !this.url || this.url === \"\\\\0\\\\\"\r\n  }\r\n\r\n  public isParameterized(): boolean {\r\n    return this.argsCount > 0\r\n  }\r\n\r\n  /**\r\n   * Creates a new Radon Retrieval by orderly replacing indexed wildcards with given parameters.\r\n   * Fails if not parameterized, of if passing too many parameters. \r\n   */\r\n  public foldArgs(args: any | string[]): RadonRetrieval {\r\n    if (this.argsCount === 0) {\r\n      throw new TypeError(`RadonRetrieval: cannot fold unparameterized retrieval`)\r\n    } \r\n    const params: string[] = []\r\n    if (Array.isArray(args)) {\r\n      if ((args as any[]).length > this.argsCount) {\r\n        throw new TypeError(`RadonRetrieval: too may args passed: ${args.length} > ${this.argsCount}`)\r\n      }\r\n      params.push(...args as string[])\r\n    \r\n    } else if (typeof args === 'object') {\r\n      if (!this.argsKeys) {\r\n        throw new TypeError(`RadonRetrieval: unexpected args map: undefined args keys.`)\r\n      } else {\r\n        this.argsKeys.forEach(key => {\r\n          if (!args[key]) {\r\n            throw new TypeError(`RadonRetrieval: missing value for parameter \"${key}\".`)\r\n          }\r\n          params.push(args[key] as string)\r\n        })\r\n      }\r\n    \r\n    } else {\r\n      params.push(args as string)\r\n    }\r\n    return new RadonRetrieval({\r\n      method: this.method,\r\n      url: replaceWildcards(this.url, params),\r\n      body: replaceWildcards(this.body, params),\r\n      headers: Object.fromEntries(Object.entries(this.headers || {}).map(([key, value]) => [\r\n        replaceWildcards(key, params),\r\n        replaceWildcards(value, params),\r\n      ])),\r\n      script: this.script?.replaceWildcards(...params),\r\n    })\r\n  }\r\n  \r\n  /**\r\n   * Creates one or more clones of this retrieval, in which the index-0 wildcard\r\n   * will be replaced by the given values. Fails if the retrieval is not parameterized.\r\n   */\r\n  public spawnRetrievals(...values: string[]): RadonRetrieval[] {\r\n    const _spawned: RadonRetrieval[] = []\r\n    if (this.argsCount == 0) {\r\n      throw new TypeError(`RadonRetrieval: cannot spawn from unparameterized retrieval`);\r\n    }\r\n    values.forEach(value => {\r\n      _spawned.push(new RadonRetrieval({\r\n        method: this.method,\r\n        url: spliceWildcard(this.url, 0, value, this.argsCount),\r\n        body: spliceWildcard(this.body, 0, value, this.argsCount),\r\n        headers: Object.fromEntries(Object.entries(this.headers || {}).map(([headerKey, headerValue]) => [\r\n          spliceWildcard(headerKey, 0, value, this.argsCount),\r\n          spliceWildcard(headerValue, 0, value, this.argsCount),\r\n        ])),\r\n        script: this.script?.spliceWildcard(0, value),\r\n        argsKeys: this.argsKeys?.slice(1),\r\n      }))\r\n    })\r\n    return _spawned\r\n  }\r\n\r\n  public toJSON(humanize?: boolean): any {\r\n    const kind = [\"\", \"HTTP-GET\", \"RNG\", \"HTTP-POST\", \"HTTP-HEAD\"]\r\n    let json: any = {\r\n      kind: kind[this.method] // humanize ? Methods[this.method] : this.method,\r\n    }\r\n    if (this.url) json.url = this.url\r\n    if (this.headers) {\r\n      json.headers = Object.entries(this.headers);\r\n    }\r\n    if (this.body) json.body = this.body\r\n    json.script = humanize ? this.script?.toString() : Array.from(fromHexString(this.script?.toBytecode() || '0x80'))\r\n    return json\r\n  }\r\n\r\n  public toProtobuf(): any {\r\n    let protobuf: any = {\r\n      kind: this.method,\r\n    }\r\n    if (this.url) protobuf.url = this.url\r\n    if (this.headers) {\r\n      protobuf.headers = Object.entries(this.headers).map(([headerKey, headerValue]) => {\r\n        return {\r\n          left: headerKey,\r\n          right: headerValue,\r\n        }\r\n      })\r\n    }\r\n    if (this.body) {\r\n      const utf8Array = toUtf8Array(this.body)\r\n      protobuf.body = utf8Array\r\n    }\r\n    protobuf.script = Object.values(Uint8Array.from(cborEncode(this.script?.encode() || [])))\r\n    return protobuf\r\n  }\r\n\r\n  public opsCount(): any {\r\n    return this._countOps(this.script?.encode() || [])\r\n  }\r\n\r\n  protected _countOps(items: any[]): number {\r\n    return items.length > 0 ? items.map(item => Array.isArray(item) ? this._countOps(item) : 1).reduce((sum, a) => sum + a) : 0\r\n  }\r\n}\r\n\r\nexport namespace filters {\r\n  export const Opcodes = Filters\r\n  export const Class = RadonFilter\r\n  export function Mode() { return new RadonFilter(Filters.Mode); }\r\n  export function Stdev(stdev: number) { return new RadonFilter(Filters.StandardDeviation, stdev); }\r\n}\r\n\r\nexport namespace reducers {\r\n  export const Opcodes = Reducers\r\n  export const Class = RadonReducer\r\n  export function Mode(...filters: RadonFilter[]) { return new RadonReducer(Reducers.Mode, filters); }\r\n  export function Mean(...filters: RadonFilter[]) { return new RadonReducer(Reducers.MeanAverage, filters); }\r\n  export function Median(...filters: RadonFilter[]) { return new RadonReducer(Reducers.MedianAverage, filters); }\r\n  export function Stdev(...filters: RadonFilter[]) { return new RadonReducer(Reducers.StandardDeviation, filters); }\r\n  export function ConcatHash(...filters: RadonFilter[]) { return new RadonReducer(Reducers.ConcatenateAndHash, filters); }\r\n\r\n  export function PriceAggregate() { return new RadonReducer(Reducers.MeanAverage, [filters.Stdev(1.4)]); }\r\n  export function PriceTally() { return new RadonReducer(Reducers.MeanAverage, [filters.Stdev(2.5)]); }\r\n}\r\n\r\nimport * as ccdr from './ccdr'\r\nexport namespace retrievals {\r\n\r\n  export const rpc = ccdr;\r\n\r\n  export function fromRadonAssets(assets: Object): Record<string, RadonRetrieval> {\r\n    return new Proxy(assets, proxyHandler(RadonRetrieval))\r\n  }\r\n\r\n  export enum Methods {\r\n    None = 0x0,\r\n    HttpGet = 0x01,\r\n    HttpHead = 0x04,\r\n    HttpPost = 0x03,\r\n    RNG = 0x02,\r\n  }\r\n\r\n  /**\r\n   * Creates a Witnet randomness data source object.\r\n   * @param script (Optional) Radon Script to apply to the random seed proposed by every single witness, \r\n   * before aggregation.\r\n  **/\r\n  export function RNG(script?: RadonAny) {\r\n    const retrieval = new RadonRetrieval({ method: Methods.RNG, script });\r\n    if (retrieval?.script && retrieval?.script?.inputType?.constructor.name !== \"RadonBytes\") {\r\n      throw new TypeError(\"RNG scripts require [RadonBytes] as input type\")\r\n    }\r\n    return retrieval\r\n  };\r\n\r\n  /**\r\n   * Creates a HTTP/GET data retrieval object.\r\n   * @param specs Radon Retrieval specs.\r\n  **/\r\n  export function HttpGet(specs: {\r\n    /**\r\n     * HTTP request URL.\r\n     */\r\n    url?: string,\r\n    /**\r\n     * HTTP request headers.\r\n     */\r\n    headers?: Record<string, string>,\r\n    /**\r\n     * RadonScript for processing returned value.\r\n     */\r\n    script?: RadonAny,\r\n    /**\r\n     * Names of indexed parameters (optional, if any).\r\n     */\r\n    argsKeys?: string[],\r\n    /**\r\n     * Map of pre-set parameters (on parameterized retrievals, only).\r\n     */\r\n    samples?: Record<string, string[]>\r\n  }) {\r\n    return new RadonRetrieval({\r\n        method: Methods.HttpGet, \r\n        url: specs?.url,\r\n        headers: specs?.headers,\r\n        script: specs?.script,\r\n        argsKeys: specs?.argsKeys,\r\n      },\r\n      specs?.samples,\r\n    );\r\n  };\r\n\r\n  /**\r\n   * Creates a HTTP/HEAD data retrieval object.\r\n   * @param specs Radon Retrieval specs.\r\n  **/\r\n  export function HttpHead(specs: {\r\n    /**\r\n     * HTTP request URL\r\n     */\r\n    url?: string,\r\n    /**\r\n     * HTTP request headers\r\n     */\r\n    headers?: Record<string, string>,\r\n    /**\r\n     * Radon script for processing returned value.\r\n     */\r\n    script?: RadonAny,\r\n    /**\r\n     * Names of indexed parameters (optional, if any)\r\n     */\r\n    argsKeys?: string[],\r\n    /**\r\n     * Map of pre-set parameters (on parameterized retrievals, only).\r\n     */\r\n    samples?: Record<string, string[]>\r\n  }) {\r\n    return new RadonRetrieval({\r\n        method: Methods.HttpHead,\r\n        url: specs?.url,\r\n        headers: specs?.headers,\r\n        script: specs?.script,\r\n        argsKeys: specs?.argsKeys,\r\n      },\r\n      specs?.samples,\r\n    );\r\n  };\r\n\r\n  /**\r\n   * Creates a HTTP/POST data retrieval object.\r\n   * @param specs Radon Retrieval specs.\r\n  **/\r\n  export function HttpPost(specs: {\r\n    /**\r\n     * HTTP request URL\r\n     */\r\n    url?: string,\r\n    /**\r\n     * HTTP request body\r\n     */\r\n    body?: string,\r\n    /**\r\n     * HTTP request headers\r\n     */\r\n    headers?: Record<string, string>,\r\n    /**\r\n     * Radon script for processing returned value.\r\n     */\r\n    script?: RadonAny,\r\n    /**\r\n     * Names of indexed parameters (optional, if any)\r\n     */\r\n    argsKeys?: string[],\r\n    /**\r\n     * Map of pre-set parameters (on parameterized retrievals, only).\r\n     */\r\n    samples?: Record<string, string[]>,\r\n  }) {\r\n    return new RadonRetrieval(\r\n      {\r\n        method: Methods.HttpPost,\r\n        url: specs?.url,\r\n        headers: specs?.headers,\r\n        body: specs?.body,\r\n        script: specs?.script,\r\n        argsKeys: specs?.argsKeys,\r\n      },\r\n      specs?.samples,\r\n    );\r\n  };\r\n\r\n  /**\r\n   * Creates a GraphQL-query data source object.\r\n   * @param specs Radon Retrieval specs.\r\n  **/\r\n  export function GraphQLQuery(specs: {\r\n    /**\r\n     * GraphQL URL endpoint\r\n     */\r\n    url?: string,\r\n    /**\r\n     * GraphQL query\r\n     */\r\n    query: string,\r\n    /**\r\n     * Radon script for processing returned value.\r\n     */\r\n    script?: RadonAny,\r\n    /**\r\n     * Names of indexed parameters (optional, if any)\r\n     */\r\n    argsKeys?: string[],\r\n    /**\r\n     * Map of pre-set parameters (on parameterized retrievals, only).\r\n     */\r\n    samples?: Record<string, string[]>,\r\n  }) {\r\n    return new RadonRetrieval(\r\n      {\r\n        method: Methods.HttpPost,\r\n        url: specs.url,\r\n        body: `{\\\"query\\\":\\\"${graphQlCompress(specs.query).replaceAll('\"', '\\\\\"')}\\\"}`,\r\n        headers: { \"Content-Type\": \"application/json;charset=UTF-8\" },\r\n        script: specs?.script,\r\n        argsKeys: specs?.argsKeys,\r\n      },\r\n      specs?.samples\r\n    );\r\n  };\r\n\r\n  /**\r\n   * Creates a JSON-RPC data retrieval object.\r\n   * @param specs Radon Retrieval specs.\r\n  **/\r\n  export function JsonRPC(specs : {\r\n    /**\r\n     * JSON-RPC method and parameters.\r\n     */\r\n    rpc: { method: string, params?: any },\r\n    /**\r\n     * Radon script for processing returned value.\r\n     */\r\n    script?: RadonAny,\r\n    /**\r\n     * Names of indexed parameters (optional, if any)\r\n     */\r\n    argsKeys?: string[],\r\n    /**\r\n     * Map of pre-set parameters (on parameterized retrievals, only).\r\n     */\r\n    samples?: Record<string, string[]>,\r\n  }) {\r\n    return new RadonRetrieval(\r\n      {\r\n        method: retrievals.Methods.HttpPost,\r\n        url: \"\\\\0\\\\\",\r\n        body: JSON.stringify({\r\n            jsonrpc: \"2.0\",\r\n            method: specs.rpc.method,\r\n            params: specs.rpc?.params,\r\n            id: 1,\r\n        }).replaceAll('\\\\\\\\', '\\\\'),\r\n        headers: { \"Content-Type\": \"application/json;charset=UTF-8\" },\r\n        script: specs?.script,\r\n        argsKeys: specs?.argsKeys,\r\n      },\r\n      specs?.samples\r\n    );\r\n  }\r\n}\r\nexport namespace types {\r\n  export const RadonArray = _RadonArray;\r\n  export const RadonBoolean = _RadonBoolean;\r\n  export const RadonBytes = _RadonBytes;\r\n  export const RadonFloat = _RadonFloat;\r\n  export const RadonInteger = _RadonInteger;\r\n  export const RadonMap = _RadonMap;\r\n  export const RadonScript = _RadonScript;\r\n  export const RadonString = _RadonString;\r\n}\r\n\r\nfunction proxyHandler<T>(t: { new(specs: any): T; }) {\r\n    return {\r\n        get(target: any, prop: string) {\r\n            let found = target[prop] ?? findKeyInObject(target, prop)\r\n            // if (!found) {\r\n            //     throw EvalError(`['${prop}'] was not found in dictionary`)\r\n            // } else \r\n            if (found && !(found instanceof t)) {\r\n                throw TypeError(`['${prop}'] was found with type ${found?.constructor?.name} instead of ${t.name}!`)\r\n            }\r\n            return found\r\n        }\r\n    }\r\n}\r\n\r\nfunction findKeyInObject(dict: any, tag: string) {\r\n    for (const key in dict) {\r\n        if (typeof dict[key] === 'object') {\r\n            if (key === tag) {\r\n                return dict[key]\r\n            } else {\r\n                let found: any = findKeyInObject(dict[key], tag)\r\n                if (found) return found\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n"]}