@witnet/solidity 3.0.4 → 3.0.5

package/dist/src/bin/helpers.cjs

@@ -0,0 +1,350 @@
+"use strict";
+const fs = require("node:fs");
+const merge = require("lodash.merge");
+const addresses = require("../../migrations/addresses.json");
+const artifacts = require("../../migrations/settings/artifacts.js").default;
+const constructorArgs = require("../../migrations/constructorArgs.json");
+const DEFAULT_BATCH_SIZE = 64;
+const DEFAULT_LIMIT = 64;
+const DEFAULT_SINCE = -5000;
+const WITNET_SDK_RADON_ASSETS_PATH = process.env.WITNET_SDK_RADON_ASSETS_PATH || "../../../../witnet/assets";
+const isModuleInitialized = fs.existsSync("./witnet/assets/index.cjs");
+function* chunks(arr, n) {
+    for (let i = 0; i < arr.length; i += n) {
+        yield arr.slice(i, i + n);
+    }
+}
+const colors = {
+    blue: (str) => `\x1b[34m${str}\x1b[0m`,
+    cyan: (str) => `\x1b[36m${str}\x1b[0m`,
+    gray: (str) => `\x1b[90m${str}\x1b[0m`,
+    green: (str) => `\x1b[32m${str}\x1b[0m`,
+    magenta: (str) => `\x1b[0;35m${str}\x1b[0m`,
+    red: (str) => `\x1b[31m${str}\x1b[0m`,
+    yellow: (str) => `\x1b[33m${str}\x1b[0m`,
+    white: (str) => `\x1b[0;38m${str}\x1b[0m`,
+    lblue: (str) => `\x1b[1;94m${str}\x1b[0m`,
+    lcyan: (str) => `\x1b[1;96m${str}\x1b[0m`,
+    lgreen: (str) => `\x1b[1;92m${str}\x1b[0m`,
+    lmagenta: (str) => `\x1b[1;95m${str}\x1b[0m`,
+    lwhite: (str) => `\x1b[0;1;98m${str}\x1b[0m`,
+    lyellow: (str) => `\x1b[1;93m${str}\x1b[0m`,
+    mblue: (str) => `\x1b[94m${str}\x1b[0m`,
+    mcyan: (str) => `\x1b[96m${str}\x1b[0m`,
+    mgreen: (str) => `\x1b[92m${str}\x1b[0m`,
+    mmagenta: (str) => `\x1b[0;95m${str}\x1b[0m`,
+    mred: (str) => `\x1b[91m${str}\x1b[0m`,
+    myellow: (str) => `\x1b[93m${str}\x1b[0m`,
+};
+const colorstrip = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+const commas = (number) => {
+    const parts = number?.toString().split(".") || [""];
+    const result = parts.length <= 1
+        ? `${parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",")}`
+        : `${parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",")}.${parts[1]}`;
+    return result;
+};
+function deleteExtraFlags(args) {
+    const deleted = [];
+    return [
+        args?.filter((arg) => {
+            if (arg.startsWith("--")) {
+                deleted.push(arg.slice(2));
+                return false;
+            }
+            else {
+                return true;
+            }
+        }),
+        deleted,
+    ];
+}
+function extractFlagsFromArgs(args, flags) {
+    const curated = {};
+    if (args && Array.isArray(args) && flags) {
+        flags.forEach((flag) => {
+            const index = args.indexOf(`--${flag}`);
+            if (index >= 0) {
+                curated[flag] = true;
+                args.splice(index, 1);
+            }
+        });
+    }
+    return [args || [], curated];
+}
+function extractOptionsFromArgs(args, options) {
+    const curated = {};
+    if (args && Array.isArray(args) && options) {
+        options.forEach((option) => {
+            const index = args.indexOf(`--${option}`);
+            if (index >= 0) {
+                curated[option] = args[index];
+                if (!args[index + 1] || args[index + 1].startsWith("--")) {
+                    args.splice(index, 1);
+                    curated[option] = undefined;
+                }
+                else {
+                    curated[option] = args[index + 1];
+                    args.splice(index, 2);
+                }
+            }
+        });
+    }
+    return [args || [], curated];
+}
+function flattenObject(ob) {
+    const toReturn = {};
+    for (const i in ob) {
+        if (!Object.hasOwn(ob, i))
+            continue;
+        if (typeof ob[i] === "object" && ob[i] !== null) {
+            const flatObject = flattenObject(ob[i]);
+            for (const x in flatObject) {
+                if (!Object.hasOwn(flatObject, x))
+                    continue;
+                toReturn[`${i}.${x}`] = flatObject[x];
+            }
+        }
+        else {
+            toReturn[i] = ob[i];
+        }
+    }
+    return toReturn;
+}
+function getNetworkAddresses(network) {
+    let res = addresses?.default;
+    getNetworkTagsFromString(network).forEach((net) => {
+        res = merge(res, addresses[net]);
+    });
+    return merge(res, fs.existsSync(`${WITNET_SDK_RADON_ASSETS_PATH}/../addresses.json`)
+        ? require(`${WITNET_SDK_RADON_ASSETS_PATH}/../addresses.json`)[network.toLowerCase()]
+        : {});
+}
+function getNetworkArtifacts(network) {
+    let res = artifacts?.default;
+    getNetworkTagsFromString(network).forEach((net) => {
+        res = merge(res, artifacts[net]);
+    });
+    return res;
+}
+function getNetworkConstructorArgs(network) {
+    let res = {};
+    getNetworkTagsFromString(network).forEach((net) => {
+        res = merge(res, constructorArgs[net]);
+    });
+    return res;
+}
+function getNetworkTagsFromString(network) {
+    network = network ? network.toLowerCase() : "development";
+    const tags = [];
+    const parts = network.split(":");
+    for (let ix = 0; ix < parts.length; ix++) {
+        tags.push(parts.slice(0, ix + 1).join(":"));
+    }
+    return tags;
+}
+function importRadonAssets(options) {
+    const assets = options?.legacy ? {} : require("@witnet/sdk/assets");
+    return isModuleInitialized &&
+        fs.existsSync(`${WITNET_SDK_RADON_ASSETS_PATH}/index.cjs`)
+        ? merge(assets, require(`${WITNET_SDK_RADON_ASSETS_PATH}/index.cjs`))
+        : assets;
+}
+function orderKeys(obj) {
+    const keys = Object.keys(obj).sort(function keyOrder(k1, k2) {
+        if (k1 < k2)
+            return -1;
+        else if (k1 > k2)
+            return +1;
+        else
+            return 0;
+    });
+    let i;
+    const after = {};
+    for (i = 0; i < keys.length; i++) {
+        after[keys[i]] = obj[keys[i]];
+        delete obj[keys[i]];
+    }
+    for (i = 0; i < keys.length; i++) {
+        obj[keys[i]] = after[keys[i]];
+    }
+    return obj;
+}
+function prompter(promise) {
+    const loading = (() => {
+        const h = ["|", "/", "-", "\\"];
+        let i = 0;
+        return setInterval(() => {
+            i = i > 3 ? 0 : i;
+            process.stdout.write(`\b\b${h[i]} `);
+            i++;
+        }, 50);
+    })();
+    return promise.then((result) => {
+        clearInterval(loading);
+        process.stdout.write("\b\b");
+        return result;
+    });
+}
+function readWitnetJsonFiles(...filenames) {
+    return Object.fromEntries(filenames.map((key) => {
+        const filepath = `./witnet/${key}.json`;
+        return [
+            key,
+            fs.existsSync(filepath) ? JSON.parse(fs.readFileSync(filepath)) : {},
+        ];
+    }));
+}
+function saveWitnetJsonFiles(data) {
+    Object.entries(data).forEach(([key, obj]) => {
+        const filepath = `./witnet/${key}.json`;
+        if (!fs.existsSync(filepath))
+            fs.writeFileSync(filepath, "{}");
+        const json = merge(JSON.parse(fs.readFileSync(filepath)), obj);
+        fs.writeFileSync(filepath, JSON.stringify(json, null, 4), { flag: "w+" });
+    });
+}
+function supportedNetworks(ecosystem) {
+    const networks = require("../../migrations/settings/networks.js").default;
+    return Object.fromEntries(Object.keys(constructorArgs)
+        .sort()
+        .filter((network) => network.indexOf(":") >= 0 &&
+        (!ecosystem || network.startsWith(ecosystem.toLowerCase())))
+        .map((network) => {
+        return [
+            network,
+            {
+                mainnet: networks[network]?.mainnet || false,
+                network_id: networks[network].network_id,
+                port: networks[network].port,
+                symbol: networks[network]?.symbol || "ETH",
+                verified: networks[network]?.verify?.explorerUrl,
+            },
+        ];
+    }));
+}
+function supportsNetwork(network) {
+    return network && Object.keys(constructorArgs).includes(network.toLowerCase());
+}
+function traceHeader(header, color = colors.white, indent = "") {
+    console.info(`${indent}┌─${"─".repeat(header.length)}─┐`);
+    console.info(`${indent}│ ${color(header)} │`);
+    console.info(`${indent}└─${"─".repeat(header.length)}─┘`);
+}
+function traceTable(records, options) {
+    const stringify = (data, humanizers, index) => humanizers?.[index]
+        ? humanizers[index](data).toString()
+        : (data?.toString() ?? "");
+    const reduceMax = (numbers) => numbers.reduce((curr, prev) => Math.max(curr, prev), 0);
+    if (!options)
+        options = {};
+    const indent = options?.indent || "";
+    const numColumns = reduceMax(records.map((record) => record?.length || 1));
+    const maxColumnWidth = options?.maxColumnWidth || 80;
+    const table = transpose(records, numColumns);
+    options.widths =
+        options?.widths ||
+            table.map((column, index) => {
+                let maxWidth = reduceMax(column.map((field) => colorstrip(stringify(field, options?.humanizers, index)).length));
+                if (options?.headlines?.[index]) {
+                    maxWidth = Math.max(maxWidth, colorstrip(options.headlines[index].replaceAll(":", "")).length);
+                }
+                return Math.min(maxWidth, maxColumnWidth);
+            });
+    let headline = options.widths.map((maxWidth) => "─".repeat(maxWidth));
+    console.info(`${indent}┌─${headline.join("─┬─")}─┐`);
+    if (options?.headlines) {
+        headline = options.widths.map((maxWidth, index) => {
+            const caption = options.headlines[index].replaceAll(":", "");
+            const captionLength = colorstrip(caption).length;
+            return `${colors.white(caption)}${" ".repeat(maxWidth - captionLength)}`;
+        });
+        console.info(`${indent}│ ${headline.join(" │ ")} │`);
+        headline = options.widths.map((maxWidth) => "─".repeat(maxWidth));
+        console.info(`${indent}├─${headline.join("─┼─")}─┤`);
+    }
+    for (let i = 0; i < records.length; i++) {
+        let line = "";
+        for (let j = 0; j < numColumns; j++) {
+            let data = table[j][i];
+            let color;
+            if (options?.colors?.[j]) {
+                color = options.colors[j];
+            }
+            else {
+                color =
+                    typeof data === "string"
+                        ? colors.green
+                        : Number(data) === data && data % 1 !== 0 // is float number?
+                            ? colors.yellow
+                            : (x) => x;
+            }
+            data = stringify(data, options?.humanizers, j);
+            if (colorstrip(data).length > maxColumnWidth) {
+                while (colorstrip(data).length > maxColumnWidth - 3) {
+                    data = data.slice(0, -1);
+                }
+                data += "...";
+            }
+            const dataLength = colorstrip(data).length;
+            if (options?.headlines && options.headlines[j][0] === ":") {
+                data = `${color(data)}${" ".repeat(options.widths[j] - dataLength)}`;
+            }
+            else {
+                data = `${" ".repeat(options.widths[j] - dataLength)}${color(data)}`;
+            }
+            line += `│ ${data} `;
+        }
+        console.info(`${indent}${line}│`);
+    }
+    headline = options.widths.map((maxWidth) => "─".repeat(maxWidth));
+    console.info(`${indent}└─${headline.join("─┴─")}─┘`);
+}
+function transpose(records, numColumns) {
+    const columns = [];
+    for (let index = 0; index < numColumns; index++) {
+        columns.push(records.map((row) => row[index]));
+    }
+    return columns;
+}
+function traceData(header, data, width, color) {
+    process.stdout.write(header);
+    if (color)
+        process.stdout.write(color);
+    for (let ix = 0; ix < data.length / width; ix++) {
+        if (ix > 0)
+            process.stdout.write(" ".repeat(header.length));
+        process.stdout.write(data.slice(width * ix, width * (ix + 1)));
+        process.stdout.write("\n");
+    }
+    if (color)
+        process.stdout.write("\x1b[0m");
+}
+module.exports = {
+    DEFAULT_BATCH_SIZE,
+    DEFAULT_LIMIT,
+    DEFAULT_SINCE,
+    colors,
+    chunks,
+    deleteExtraFlags,
+    extractFlagsFromArgs,
+    extractOptionsFromArgs,
+    flattenObject,
+    orderKeys,
+    traceData,
+    traceHeader,
+    getNetworkAddresses,
+    getNetworkArtifacts,
+    getNetworkConstructorArgs,
+    getNetworkTagsFromString,
+    supportedNetworks,
+    supportsNetwork,
+    importRadonAssets,
+    readWitnetJsonFiles,
+    saveWitnetJsonFiles,
+    traceTable,
+    commas,
+    colorstrip,
+    prompter,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.cjs","sourceRoot":"","sources":["../../../src/bin/helpers.cjs"],"names":[],"mappings":"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","sourcesContent":["const fs = require(\"node:fs\")\nconst merge = require(\"lodash.merge\")\n\nconst addresses = require(\"../../migrations/addresses.json\")\nconst artifacts = require(\"../../migrations/settings/artifacts.js\").default\nconst constructorArgs = require(\"../../migrations/constructorArgs.json\")\n\nconst DEFAULT_BATCH_SIZE = 64\nconst DEFAULT_LIMIT = 64\nconst DEFAULT_SINCE = -5000\nconst WITNET_SDK_RADON_ASSETS_PATH =\n\tprocess.env.WITNET_SDK_RADON_ASSETS_PATH || \"../../../../witnet/assets\"\n\nconst isModuleInitialized = fs.existsSync(\"./witnet/assets/index.cjs\")\n\nfunction* chunks(arr, n) {\n\tfor (let i = 0; i < arr.length; i += n) {\n\t\tyield arr.slice(i, i + n)\n\t}\n}\n\nconst colors = {\n\tblue: (str) => `\\x1b[34m${str}\\x1b[0m`,\n\tcyan: (str) => `\\x1b[36m${str}\\x1b[0m`,\n\tgray: (str) => `\\x1b[90m${str}\\x1b[0m`,\n\tgreen: (str) => `\\x1b[32m${str}\\x1b[0m`,\n\tmagenta: (str) => `\\x1b[0;35m${str}\\x1b[0m`,\n\tred: (str) => `\\x1b[31m${str}\\x1b[0m`,\n\tyellow: (str) => `\\x1b[33m${str}\\x1b[0m`,\n\twhite: (str) => `\\x1b[0;38m${str}\\x1b[0m`,\n\tlblue: (str) => `\\x1b[1;94m${str}\\x1b[0m`,\n\tlcyan: (str) => `\\x1b[1;96m${str}\\x1b[0m`,\n\tlgreen: (str) => `\\x1b[1;92m${str}\\x1b[0m`,\n\tlmagenta: (str) => `\\x1b[1;95m${str}\\x1b[0m`,\n\tlwhite: (str) => `\\x1b[0;1;98m${str}\\x1b[0m`,\n\tlyellow: (str) => `\\x1b[1;93m${str}\\x1b[0m`,\n\tmblue: (str) => `\\x1b[94m${str}\\x1b[0m`,\n\tmcyan: (str) => `\\x1b[96m${str}\\x1b[0m`,\n\tmgreen: (str) => `\\x1b[92m${str}\\x1b[0m`,\n\tmmagenta: (str) => `\\x1b[0;95m${str}\\x1b[0m`,\n\tmred: (str) => `\\x1b[91m${str}\\x1b[0m`,\n\tmyellow: (str) => `\\x1b[93m${str}\\x1b[0m`,\n}\n\nconst colorstrip = (str) =>\n\tstr.replace(\n\t\t/[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,\n\t\t\"\",\n\t)\n\nconst commas = (number) => {\n\tconst parts = number?.toString().split(\".\") || [\"\"]\n\tconst result =\n\t\tparts.length <= 1\n\t\t\t? `${parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, \",\")}`\n\t\t\t: `${parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, \",\")}.${parts[1]}`\n\treturn result\n}\n\nfunction deleteExtraFlags(args) {\n\tconst deleted = []\n\treturn [\n\t\targs?.filter((arg) => {\n\t\t\tif (arg.startsWith(\"--\")) {\n\t\t\t\tdeleted.push(arg.slice(2))\n\t\t\t\treturn false\n\t\t\t} else {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}),\n\t\tdeleted,\n\t]\n}\n\nfunction extractFlagsFromArgs(args, flags) {\n\tconst curated = {}\n\tif (args && Array.isArray(args) && flags) {\n\t\tflags.forEach((flag) => {\n\t\t\tconst index = args.indexOf(`--${flag}`)\n\t\t\tif (index >= 0) {\n\t\t\t\tcurated[flag] = true\n\t\t\t\targs.splice(index, 1)\n\t\t\t}\n\t\t})\n\t}\n\treturn [args || [], curated]\n}\n\nfunction extractOptionsFromArgs(args, options) {\n\tconst curated = {}\n\tif (args && Array.isArray(args) && options) {\n\t\toptions.forEach((option) => {\n\t\t\tconst index = args.indexOf(`--${option}`)\n\t\t\tif (index >= 0) {\n\t\t\t\tcurated[option] = args[index]\n\t\t\t\tif (!args[index + 1] || args[index + 1].startsWith(\"--\")) {\n\t\t\t\t\targs.splice(index, 1)\n\t\t\t\t\tcurated[option] = undefined\n\t\t\t\t} else {\n\t\t\t\t\tcurated[option] = args[index + 1]\n\t\t\t\t\targs.splice(index, 2)\n\t\t\t\t}\n\t\t\t}\n\t\t})\n\t}\n\treturn [args || [], curated]\n}\n\nfunction flattenObject(ob) {\n\tconst toReturn = {}\n\tfor (const i in ob) {\n\t\tif (!Object.hasOwn(ob, i)) continue\n\t\tif (typeof ob[i] === \"object\" && ob[i] !== null) {\n\t\t\tconst flatObject = flattenObject(ob[i])\n\t\t\tfor (const x in flatObject) {\n\t\t\t\tif (!Object.hasOwn(flatObject, x)) continue\n\t\t\t\ttoReturn[`${i}.${x}`] = flatObject[x]\n\t\t\t}\n\t\t} else {\n\t\t\ttoReturn[i] = ob[i]\n\t\t}\n\t}\n\treturn toReturn\n}\n\nfunction getNetworkAddresses(network) {\n\tlet res = addresses?.default\n\tgetNetworkTagsFromString(network).forEach((net) => {\n\t\tres = merge(res, addresses[net])\n\t})\n\treturn merge(\n\t\tres,\n\t\tfs.existsSync(`${WITNET_SDK_RADON_ASSETS_PATH}/../addresses.json`)\n\t\t\t? require(`${WITNET_SDK_RADON_ASSETS_PATH}/../addresses.json`)[\n\t\t\t\t\tnetwork.toLowerCase()\n\t\t\t\t]\n\t\t\t: {},\n\t)\n}\n\nfunction getNetworkArtifacts(network) {\n\tlet res = artifacts?.default\n\tgetNetworkTagsFromString(network).forEach((net) => {\n\t\tres = merge(res, artifacts[net])\n\t})\n\treturn res\n}\n\nfunction getNetworkConstructorArgs(network) {\n\tlet res = {}\n\tgetNetworkTagsFromString(network).forEach((net) => {\n\t\tres = merge(res, constructorArgs[net])\n\t})\n\treturn res\n}\n\nfunction getNetworkTagsFromString(network) {\n\tnetwork = network ? network.toLowerCase() : \"development\"\n\tconst tags = []\n\tconst parts = network.split(\":\")\n\tfor (let ix = 0; ix < parts.length; ix++) {\n\t\ttags.push(parts.slice(0, ix + 1).join(\":\"))\n\t}\n\treturn tags\n}\n\nfunction importRadonAssets(options) {\n\tconst assets = options?.legacy ? {} : require(\"@witnet/sdk/assets\")\n\treturn isModuleInitialized &&\n\t\tfs.existsSync(`${WITNET_SDK_RADON_ASSETS_PATH}/index.cjs`)\n\t\t? merge(assets, require(`${WITNET_SDK_RADON_ASSETS_PATH}/index.cjs`))\n\t\t: assets\n}\n\nfunction orderKeys(obj) {\n\tconst keys = Object.keys(obj).sort(function keyOrder(k1, k2) {\n\t\tif (k1 < k2) return -1\n\t\telse if (k1 > k2) return +1\n\t\telse return 0\n\t})\n\tlet i\n\tconst after = {}\n\tfor (i = 0; i < keys.length; i++) {\n\t\tafter[keys[i]] = obj[keys[i]]\n\t\tdelete obj[keys[i]]\n\t}\n\tfor (i = 0; i < keys.length; i++) {\n\t\tobj[keys[i]] = after[keys[i]]\n\t}\n\treturn obj\n}\n\nfunction prompter(promise) {\n\tconst loading = (() => {\n\t\tconst h = [\"|\", \"/\", \"-\", \"\\\\\"]\n\t\tlet i = 0\n\t\treturn setInterval(() => {\n\t\t\ti = i > 3 ? 0 : i\n\t\t\tprocess.stdout.write(`\\b\\b${h[i]} `)\n\t\t\ti++\n\t\t}, 50)\n\t})()\n\treturn promise.then((result) => {\n\t\tclearInterval(loading)\n\t\tprocess.stdout.write(\"\\b\\b\")\n\t\treturn result\n\t})\n}\n\nfunction readWitnetJsonFiles(...filenames) {\n\treturn Object.fromEntries(\n\t\tfilenames.map((key) => {\n\t\t\tconst filepath = `./witnet/${key}.json`\n\t\t\treturn [\n\t\t\t\tkey,\n\t\t\t\tfs.existsSync(filepath) ? JSON.parse(fs.readFileSync(filepath)) : {},\n\t\t\t]\n\t\t}),\n\t)\n}\n\nfunction saveWitnetJsonFiles(data) {\n\tObject.entries(data).forEach(([key, obj]) => {\n\t\tconst filepath = `./witnet/${key}.json`\n\t\tif (!fs.existsSync(filepath)) fs.writeFileSync(filepath, \"{}\")\n\t\tconst json = merge(JSON.parse(fs.readFileSync(filepath)), obj)\n\t\tfs.writeFileSync(filepath, JSON.stringify(json, null, 4), { flag: \"w+\" })\n\t})\n}\n\nfunction supportedNetworks(ecosystem) {\n\tconst networks = require(\"../../migrations/settings/networks.js\").default\n\treturn Object.fromEntries(\n\t\tObject.keys(constructorArgs)\n\t\t\t.sort()\n\t\t\t.filter(\n\t\t\t\t(network) =>\n\t\t\t\t\tnetwork.indexOf(\":\") >= 0 &&\n\t\t\t\t\t(!ecosystem || network.startsWith(ecosystem.toLowerCase())),\n\t\t\t)\n\t\t\t.map((network) => {\n\t\t\t\treturn [\n\t\t\t\t\tnetwork,\n\t\t\t\t\t{\n\t\t\t\t\t\tmainnet: networks[network]?.mainnet || false,\n\t\t\t\t\t\tnetwork_id: networks[network].network_id,\n\t\t\t\t\t\tport: networks[network].port,\n\t\t\t\t\t\tsymbol: networks[network]?.symbol || \"ETH\",\n\t\t\t\t\t\tverified: networks[network]?.verify?.explorerUrl,\n\t\t\t\t\t},\n\t\t\t\t]\n\t\t\t}),\n\t)\n}\n\nfunction supportsNetwork(network) {\n\treturn network && Object.keys(constructorArgs).includes(network.toLowerCase())\n}\n\nfunction traceHeader(header, color = colors.white, indent = \"\") {\n\tconsole.info(`${indent}┌─${\"─\".repeat(header.length)}─┐`)\n\tconsole.info(`${indent}│ ${color(header)} │`)\n\tconsole.info(`${indent}└─${\"─\".repeat(header.length)}─┘`)\n}\n\nfunction traceTable(records, options) {\n\tconst stringify = (data, humanizers, index) =>\n\t\thumanizers?.[index]\n\t\t\t? humanizers[index](data).toString()\n\t\t\t: (data?.toString() ?? \"\")\n\tconst reduceMax = (numbers) =>\n\t\tnumbers.reduce((curr, prev) => Math.max(curr, prev), 0)\n\tif (!options) options = {}\n\tconst indent = options?.indent || \"\"\n\tconst numColumns = reduceMax(records.map((record) => record?.length || 1))\n\tconst maxColumnWidth = options?.maxColumnWidth || 80\n\tconst table = transpose(records, numColumns)\n\toptions.widths =\n\t\toptions?.widths ||\n\t\ttable.map((column, index) => {\n\t\t\tlet maxWidth = reduceMax(\n\t\t\t\tcolumn.map(\n\t\t\t\t\t(field) =>\n\t\t\t\t\t\tcolorstrip(stringify(field, options?.humanizers, index)).length,\n\t\t\t\t),\n\t\t\t)\n\t\t\tif (options?.headlines?.[index]) {\n\t\t\t\tmaxWidth = Math.max(\n\t\t\t\t\tmaxWidth,\n\t\t\t\t\tcolorstrip(options.headlines[index].replaceAll(\":\", \"\")).length,\n\t\t\t\t)\n\t\t\t}\n\t\t\treturn Math.min(maxWidth, maxColumnWidth)\n\t\t})\n\tlet headline = options.widths.map((maxWidth) => \"─\".repeat(maxWidth))\n\tconsole.info(`${indent}┌─${headline.join(\"─┬─\")}─┐`)\n\tif (options?.headlines) {\n\t\theadline = options.widths.map((maxWidth, index) => {\n\t\t\tconst caption = options.headlines[index].replaceAll(\":\", \"\")\n\t\t\tconst captionLength = colorstrip(caption).length\n\t\t\treturn `${colors.white(caption)}${\" \".repeat(maxWidth - captionLength)}`\n\t\t})\n\t\tconsole.info(`${indent}│ ${headline.join(\" │ \")} │`)\n\t\theadline = options.widths.map((maxWidth) => \"─\".repeat(maxWidth))\n\t\tconsole.info(`${indent}├─${headline.join(\"─┼─\")}─┤`)\n\t}\n\tfor (let i = 0; i < records.length; i++) {\n\t\tlet line = \"\"\n\t\tfor (let j = 0; j < numColumns; j++) {\n\t\t\tlet data = table[j][i]\n\t\t\tlet color\n\t\t\tif (options?.colors?.[j]) {\n\t\t\t\tcolor = options.colors[j]\n\t\t\t} else {\n\t\t\t\tcolor =\n\t\t\t\t\ttypeof data === \"string\"\n\t\t\t\t\t\t? colors.green\n\t\t\t\t\t\t: Number(data) === data && data % 1 !== 0 // is float number?\n\t\t\t\t\t\t\t? colors.yellow\n\t\t\t\t\t\t\t: (x) => x\n\t\t\t}\n\t\t\tdata = stringify(data, options?.humanizers, j)\n\t\t\tif (colorstrip(data).length > maxColumnWidth) {\n\t\t\t\twhile (colorstrip(data).length > maxColumnWidth - 3) {\n\t\t\t\t\tdata = data.slice(0, -1)\n\t\t\t\t}\n\t\t\t\tdata += \"...\"\n\t\t\t}\n\t\t\tconst dataLength = colorstrip(data).length\n\t\t\tif (options?.headlines && options.headlines[j][0] === \":\") {\n\t\t\t\tdata = `${color(data)}${\" \".repeat(options.widths[j] - dataLength)}`\n\t\t\t} else {\n\t\t\t\tdata = `${\" \".repeat(options.widths[j] - dataLength)}${color(data)}`\n\t\t\t}\n\t\t\tline += `│ ${data} `\n\t\t}\n\t\tconsole.info(`${indent}${line}│`)\n\t}\n\theadline = options.widths.map((maxWidth) => \"─\".repeat(maxWidth))\n\tconsole.info(`${indent}└─${headline.join(\"─┴─\")}─┘`)\n}\n\nfunction transpose(records, numColumns) {\n\tconst columns = []\n\tfor (let index = 0; index < numColumns; index++) {\n\t\tcolumns.push(records.map((row) => row[index]))\n\t}\n\treturn columns\n}\n\nfunction traceData(header, data, width, color) {\n\tprocess.stdout.write(header)\n\tif (color) process.stdout.write(color)\n\tfor (let ix = 0; ix < data.length / width; ix++) {\n\t\tif (ix > 0) process.stdout.write(\" \".repeat(header.length))\n\t\tprocess.stdout.write(data.slice(width * ix, width * (ix + 1)))\n\t\tprocess.stdout.write(\"\\n\")\n\t}\n\tif (color) process.stdout.write(\"\\x1b[0m\")\n}\n\nmodule.exports = {\n\tDEFAULT_BATCH_SIZE,\n\tDEFAULT_LIMIT,\n\tDEFAULT_SINCE,\n\tcolors,\n\tchunks,\n\tdeleteExtraFlags,\n\textractFlagsFromArgs,\n\textractOptionsFromArgs,\n\tflattenObject,\n\torderKeys,\n\ttraceData,\n\ttraceHeader,\n\tgetNetworkAddresses,\n\tgetNetworkArtifacts,\n\tgetNetworkConstructorArgs,\n\tgetNetworkTagsFromString,\n\tsupportedNetworks,\n\tsupportsNetwork,\n\timportRadonAssets,\n\treadWitnetJsonFiles,\n\tsaveWitnetJsonFiles,\n\ttraceTable,\n\tcommas,\n\tcolorstrip,\n\tprompter,\n}\n"]}

package/dist/src/bin/helpers.d.cts

@@ -0,0 +1,76 @@
+export const DEFAULT_BATCH_SIZE: 64;
+export const DEFAULT_LIMIT: 64;
+export const DEFAULT_SINCE: -5000;
+export namespace colors {
+    function blue(str: any): string;
+    function cyan(str: any): string;
+    function gray(str: any): string;
+    function green(str: any): string;
+    function magenta(str: any): string;
+    function red(str: any): string;
+    function yellow(str: any): string;
+    function white(str: any): string;
+    function lblue(str: any): string;
+    function lcyan(str: any): string;
+    function lgreen(str: any): string;
+    function lmagenta(str: any): string;
+    function lwhite(str: any): string;
+    function lyellow(str: any): string;
+    function mblue(str: any): string;
+    function mcyan(str: any): string;
+    function mgreen(str: any): string;
+    function mmagenta(str: any): string;
+    function mred(str: any): string;
+    function myellow(str: any): string;
+}
+export function chunks(arr: any, n: any): Generator<any, void, unknown>;
+export function deleteExtraFlags(args: any): any[];
+export function extractFlagsFromArgs(args: any, flags: any): any[];
+export function extractOptionsFromArgs(args: any, options: any): any[];
+export function flattenObject(ob: any): {};
+export function orderKeys(obj: any): any;
+export function traceData(header: any, data: any, width: any, color: any): void;
+export function traceHeader(header: any, color?: (str: any) => string, indent?: string): void;
+export function getNetworkAddresses(network: any): any;
+export function getNetworkArtifacts(network: any): {
+    WitnetDeployer: string;
+    apps: {
+        WitPriceFeeds: string;
+        WitPriceFeedsLegacy: string;
+        WitRandomness: string;
+    };
+    core: {
+        WitOracle: string;
+        WitOracleRadonRegistry: string;
+        WitOracleRadonRequestFactory: string;
+        WitOracleRadonRequestFactoryModals: string;
+        WitOracleRadonRequestFactoryTemplates: string;
+    };
+    libs: {
+        WitOracleDataLib: string;
+        WitOracleRadonEncodingLib: string;
+        WitOracleResultStatusLib: string;
+        WitPriceFeedsDataLib: string;
+        WitPriceFeedsLegacyDataLib: string;
+    };
+};
+export function getNetworkConstructorArgs(network: any): {};
+export function getNetworkTagsFromString(network: any): any[];
+export function supportedNetworks(ecosystem: any): {
+    [k: string]: {
+        mainnet: any;
+        network_id: any;
+        port: any;
+        symbol: any;
+        verified: any;
+    };
+};
+export function supportsNetwork(network: any): any;
+export function importRadonAssets(options: any): any;
+export function readWitnetJsonFiles(...filenames: any[]): any;
+export function saveWitnetJsonFiles(data: any): void;
+export function traceTable(records: any, options: any): void;
+export function commas(number: any): string;
+export function colorstrip(str: any): any;
+export function prompter(promise: any): any;
+//# sourceMappingURL=helpers.d.cts.map

package/dist/src/bin/helpers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.cts","sourceRoot":"","sources":["../../../src/bin/helpers.cjs"],"names":[],"mappings":"AAOA,iCAA2B,EAAE,CAAA;AAC7B,4BAAsB,EAAE,CAAA;AACxB,4BAAsB,CAAC,IAAI,CAAA;;IAapB,gCAAgC;IAChC,gCAAgC;IAChC,gCAAgC;IAC/B,iCAAgC;IAC9B,mCAAkC;IACtC,+BAAgC;IAC7B,kCAAgC;IACjC,iCAAkC;IAClC,iCAAkC;IAClC,iCAAkC;IACjC,kCAAkC;IAChC,oCAAkC;IACpC,kCAAoC;IACnC,mCAAkC;IACpC,iCAAgC;IAChC,iCAAgC;IAC/B,kCAAgC;IAC9B,oCAAkC;IACtC,gCAAgC;IAC7B,mCAAgC;;AA1B1C,wEAIC;AAwCD,mDAaC;AAED,mEAYC;AAED,uEAkBC;AAED,2CAeC;AAmDD,yCAgBC;AAgKD,gFASC;AApGD,8FAIC;AA1ID,uDAaC;AAED;;;;;;;;;;;;;;;;;;;;;EAMC;AAED,4DAMC;AAED,8DAQC;AAkED;;;;;;;;EAuBC;AAED,mDAEC;AA3FD,qDAMC;AAqCD,8DAUC;AAED,qDAOC;AAqCD,6DA2EC;AAlSD,4CAOC;AAbD,0CAIE;AAgJF,4CAeC"}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * as ethers from "ethers";
+export * from "./lib/types.js";
+export * as utils from "./lib/utils.js";
+export * from "./lib/wrappers.js";
+export declare const ABIs: any;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAA;AACvC,cAAc,mBAAmB,CAAA;AAMjC,eAAO,MAAM,IAAI,EAAE,GAoClB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,33 @@
+export * as ethers from "ethers";
+export * from "./lib/types.js";
+export * as utils from "./lib/utils.js";
+export * from "./lib/wrappers.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export const ABIs = {
+    WitAppliance: require("../../artifacts/contracts/interfaces/IWitAppliance.sol/IWitAppliance.json")
+        .abi,
+    WitOracle: require("../../artifacts/contracts/WitOracle.sol/WitOracle.json")
+        .abi,
+    WitOracleConsumer: require("../../artifacts/contracts/interfaces/IWitOracleConsumer.sol/IWitOracleConsumer.json")
+        .abi,
+    WitOracleRadonRegistry: require("../../artifacts/contracts/WitOracleRadonRegistry.sol/WitOracleRadonRegistry.json")
+        .abi,
+    WitOracleRadonRequestFactory: require("../../artifacts/contracts/WitOracleRadonRequestFactory.sol/WitOracleRadonRequestFactory.json")
+        .abi,
+    WitOracleRadonRequestModal: require("../../artifacts/contracts/interfaces/IWitOracleRadonRequestModal.sol/IWitOracleRadonRequestModal.json")
+        .abi,
+    WitOracleRadonRequestTemplate: require("../../artifacts/contracts/interfaces/IWitOracleRadonRequestTemplate.sol/IWitOracleRadonRequestTemplate.json")
+        .abi,
+    WitPriceFeeds: require("../../artifacts/contracts/WitPriceFeeds.sol/WitPriceFeeds.json")
+        .abi,
+    WitPriceFeedsLegacy: require("../../artifacts/contracts/WitPriceFeedsLegacy.sol/WitPriceFeedsLegacy.json")
+        .abi,
+    WitRandomnessV2: require("../../artifacts/contracts/WitRandomnessLegacy.sol/WitRandomnessLegacy.json")
+        .abi,
+    WitRandomnessV3: require("../../artifacts/contracts/WitRandomness.sol/WitRandomness.json")
+        .abi,
+    WitnetUpgradableBase: require("../../artifacts/contracts/core/WitnetUpgradableBase.sol/WitnetUpgradableBase.json")
+        .abi,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/types.d.ts

@@ -0,0 +1,99 @@
+import type { Witnet } from "@witnet/sdk";
+import type { ContractWrapper } from "./wrappers/ContractWrapper.js";
+export type DataPushReport = Witnet.DataPushReport;
+export type PriceFeed = {
+    id?: string;
+    id4: string;
+    exponent: number;
+    symbol: string;
+    mapper?: PriceFeedMapper;
+    oracle?: PriceFeedOracle;
+    updateConditions?: PriceFeedUpdateConditions;
+    lastUpdate?: PriceFeedUpdate;
+};
+export type PriceFeedMapper = {
+    class: string;
+    deps: Array<string>;
+};
+export declare enum PriceFeedMappers {
+    None = 0,
+    Fallback = 1,
+    Hottest = 2,
+    Product = 3,
+    Inverse = 4
+}
+export type PriceFeedOracle = {
+    class: string;
+    target: string;
+    sources: Witnet.Hash;
+};
+export declare enum PriceFeedOracles {
+    Witnet = 0,
+    Erc2362 = 1,
+    Chainlink = 2
+}
+export type PriceFeedUpdate = {
+    price: number;
+    deltaPrice?: number;
+    exponent?: number;
+    timestamp: number;
+    trail: Witnet.Hash;
+};
+export type PriceFeedUpdateConditions = {
+    callbackGas: number;
+    computeEMA: boolean;
+    cooldownSecs: number;
+    heartbeatSecs: number;
+    maxDeviationPercentage: number;
+    minWitnesses: number;
+};
+export type RandomizeStatus = "Void" | "Awaiting" | "Finalizing" | "Ready" | "Error";
+export { TransactionReceipt } from "ethers";
+export type WitOracleArtifact = {
+    address: Witnet.HexString;
+    abi: any;
+    class: string;
+    gitHash?: string;
+    interfaceId: Witnet.HexString;
+    isUpgradable: boolean;
+    semVer?: string;
+    version?: string;
+    wrapper?: ContractWrapper;
+};
+export type WitOracleQuery = {
+    checkpoint: bigint;
+    hash: Witnet.Hash;
+    params: WitOracleQueryParams;
+    request: WitOracleQueryRequest;
+    response?: WitOracleQueryResponse;
+};
+export type WitOracleQueryParams = {
+    /**
+     * Maximum expected size of the CBOR-encoded query result, once solved by the Witnet blockchain.
+     */
+    resultMaxSize?: number;
+    /**
+     * Mininum reward in $nanoWIT for very validator that positively contributes to get the Wit/Oracle
+     * query attended, solved and stored into the Witnet blockchain.
+     */
+    unitaryReward: bigint;
+    /**
+     * Maximum number of witnessing nodes required to participate in solving the oracle query.
+     */
+    witnesses: number;
+};
+export type WitOracleQueryRequest = {
+    callbackGas?: number;
+    radonHash: Witnet.Hash;
+    requester: string;
+};
+export type WitOracleQueryResponse = {
+    disputer?: string;
+    reporter?: string;
+    resultTimestamp?: number;
+    resultDrTxHash: Witnet.Hash;
+    resultCborBytes: Witnet.HexString;
+};
+export type WitOracleQueryStatus = "Void" | "Posted" | "Reported" | "Finalized" | "Delayed" | "Expired" | "Disputed";
+export type WitOracleResultDataTypes = "any" | "array" | "boolean" | "bytes" | "float" | "integer" | "map" | "string";
+//# sourceMappingURL=types.d.ts.map

package/dist/src/lib/types.d.ts.map

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