@witnet/sdk 1.0.15 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@witnet/sdk",
-  "version": "1.0.15",
+  "version": "1.1.1",
   "description": "Typescript library and CLI tooling for Web3 buidlers willing to interact with the Witnet blockchain.",
   "author": "Witnet Foundation",
   "license": "MIT",
@@ -19,45 +19,45 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/*.d.ts",
       "require": "./dist/src/index.js",
-      "default": "./dist/src/index.js",
-      "types": "./dist/src/*.d.ts"
+      "default": "./dist/src/index.js"
     },
     "./assets": "./dist/witnet/assets/index.js",
     "./utils": {
+      "types": "./dist/src/lib/*.d.ts",
       "require": "./dist/src/lib/utils.js",
-      "default": "./dist/src/lib/utils.js",
-      "types": "./dist/src/lib/*.d.ts"
+      "default": "./dist/src/lib/utils.js"
     }
   },
   "types": "./dist",
   "dependencies": {
-    "axios": "^1.11.0",
+    "axios": "^1.12.2",
     "bech32": "~2.0.0",
     "bip32": "^4.0.0",
-    "cbor": "^10.0.10",
+    "cbor": "^10.0.11",
     "dotenv": "^16.6.1",
-    "ethers": "^5.8.0",
+    "ethers": "^6.15.0",
     "graphql-query-compress": "1.2.4",
-    "inquirer": "^12.9.1",
+    "inquirer": "^12.9.6",
     "json-bigint": "^1.0.0",
     "keccak256": "^1.0.6",
     "lodash.merge": "^4.6.2",
     "long": "^5.3.2",
     "moment": "^2.30.1",
     "promise-poller": "~1.9.1",
-    "protobufjs": "^7.5.3",
+    "protobufjs": "^7.5.4",
     "qrcode-terminal": "^0.12.0",
     "secp256k1": "^5.0.1",
     "tiny-secp256k1": "~2.2.4"
   },
   "devDependencies": {
-    "@types/node": "^22.17.1",
-    "cross-env": "7.0.3",
+    "@types/node": "^22.18.5",
+    "cross-env": "10.0.0",
     "eslint": "8.56.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^17.21.3",
+    "eslint-plugin-n": "^17.23.0",
     "eslint-plugin-promise": "^7.2.1",
     "protobufjs-cli": "^1.1.3",
     "typescript": "^5.9.2"

package/src/bin/cli/inspect.js

@@ -1,3 +1,4 @@
+const cbor = require("cbor")
 const moment = require("moment")
 
 const helpers = require("../helpers")
@@ -5,6 +6,8 @@ const { utils, Witnet } = require("../../../dist/src")
 
 const { cyan, gray, green, lyellow, magenta, mgreen, mmagenta, myellow, yellow } = helpers.colors
 
+const DEFAULT_LIMIT = 100
+
 /// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /// CLI SUBMODULE CONSTANTS ===========================================================================================
 
@@ -15,7 +18,10 @@ module.exports = {
   flags: {
     provider: {
       hint: "Public Wit/Oracle JSON-RPC provider, other than default.",
-      param: ":http-url",
+      param: "URL",
+    },
+    reverse: {
+      hint: "List most recent data requests first (default: true).",
     },
     verbose: {
       hint: "Outputs validators' nonce and last validation epochs.",
@@ -43,22 +49,22 @@ module.exports = {
         },
       },
     },
-    "dataRequests*": {
+    dataRequests: {
       hint: "Search for in-flight or recently solved data request transactions.",
-      params: "BYTECODE | RAD_HASH | DDR_HASH",
+      params: "RAD_BYTECODE | RAD_HASH",
       options: {
         limit: { hint: "Limit output records (default: 100).", param: "LIMIT" },
-        since: {
-          hint: "Number of past epochs to search for (default: 256; max: 2048).",
-          param: "EPOCH|MINUS_EPOCHS",
+        offset: {
+          hint: "Skips first records as found on server side (default: 0).",
+          param: "SKIP",
         },
-        "min-unitary-reward": {
-          hint: "Filters out those providing less unitary reward than specified.",
-          param: "NANOWITS",
+        mode: {
+          hint: "Possible report formats (default: `ethereal`).",
+          param: "`ethereal` | `full``",
         },
-        "min-witnesses": {
-          hint: "Filters out those solved with less than specified witnesses.",
-          param: "NUM_WITNESSES",
+        since: {
+          hint: "Number of past epochs to search for (default: -30240).",
+          param: "EPOCH|MINUS_EPOCHS",
         },
       },
     },
@@ -111,7 +117,7 @@ module.exports = {
     },
   },
   subcommands: {
-    balance, block, dataRequest, superblock, transaction, validators, withdrawers, utxos, valueTransfer,
+    balance, block, dataRequest, dataRequests, superblock, transaction, validators, withdrawers, utxos, valueTransfer,
   },
 }
 
@@ -167,6 +173,90 @@ async function block (options = {}, args = []) {
   }, 2)))
 }
 
+async function dataRequests(options = {}, [arg]) {
+  // if (!args || args.length === 0) {
+  if (!arg) {
+    throw new Error("No RAD_HASH or RAD_RAD_BYTECODE was specified.")
+  }
+  const provider = new Witnet.JsonRpcProvider(options?.provider)
+  // const radHashes = args.map(arg => {
+    if (!helpers.isHexString(arg)) {
+      throw new Error(`Invalid hex string was provided: '${arg}'`)
+    }
+    let radHash
+    if (helpers.isHexStringOfLength(arg, 32)) {
+      radHash = arg
+    } else {
+      const request = Witnet.Radon.RadonRequest.fromBytecode(arg)
+      radHash = request.radHash
+    }
+    // return radHash
+  // })
+  // let results = await helpers.prompter(
+  //   Promise.all(
+  //     [...new Set(radHashes)].map(radHash => provider.searchDataRequests(radHash, {
+  //       limit: options?.limit ? parseInt(options.limit) : undefined,
+  //       offset: options?.offset ? parseInt(options.offset) : undefined,
+  //       reverse: options?.reverse, 
+  //     }))
+  //   ).then(results => results
+  //     .flat()
+  //     .sort((a, b) => options?.reverse ? b.block_epoch - a.block_epoch : a.block_epoch - b.block_epoch)
+  //     .slice(options?.offset)
+  //     .slice(0, options?.limit || DEFAULT_LIMIT)
+  //   )
+  // )
+  const results = await helpers.prompter(
+    provider.searchDataRequests(radHash, {
+      limit: options?.limit ? parseInt(options.limit) : undefined,
+      offset: options?.offset ? parseInt(options.offset) : undefined,
+      mode: options?.mode,
+      reverse: options?.reverse, 
+    })
+  )
+  helpers.traceTable(
+    results.map(record => {
+      let result = record?.result.cbor_bytes ? cbor.decode(record?.result.cbor_bytes, { encoding: "hex" }) : ""
+      const request = Witnet.Radon.RadonRequest.fromBytecode(record.query.rad_bytecode)
+      const dataType = result.constructor.name === "Tagged" ? "RadonError" : request.dataType
+      if (dataType !== "RadonError") result = Buffer.from(utils.fromHexString(record?.result.cbor_bytes)).toString('base64');
+      else if (result.constructor.name === "Buffer") result = result.toString('base64');
+      return [
+        record.block_epoch,
+        record.hash,
+        record.query.witnesses,
+        Witnet.Coins.fromPedros(record.query.unitary_reward).toString(2),
+        dataType === "RadonError" ? helpers.colors.mred("RadonError") : helpers.colors.mgreen(dataType),
+        ...(options?.verbose ? [
+          dataType === "RadonError" ? helpers.colors.red(result) : (
+            record?.result.finalized ? helpers.colors.mcyan(result) : helpers.colors.cyan(result)
+          ),
+        ] : [
+          record?.result ? record.result.cbor_bytes.length / 2 + " bytes" : "",
+          record?.result.timestamp ? moment.unix(record.result.timestamp).fromNow() : "",
+        ]),
+      ]
+    }), {
+      headlines: [ 
+        "EPOCH:", 
+        "DATA REQUEST TRANSACION HASH", 
+        "witnesses", 
+        "total fees",
+        ":data type",
+        ...(options?.verbose ? [":DATA REQUEST RESULT"] : ["CBOR SIZE:", "DATA FRESHNESS:"])
+      ],
+      humanizers: [ helpers.commas ],
+      colors: [
+        , helpers.colors.gray,
+        helpers.colors.green,
+        helpers.colors.green,,
+        helpers.colors.cyan,
+        helpers.colors.mcyan,
+      ]
+    }
+  )
+}
+
 async function dataRequest (options = {}, args = []) {
   if (args.length === 0) {
     throw Error("No DR_TX_HASH was specified")

package/src/bin/cli/radon.js

@@ -1,3 +1,4 @@
+const cbor = require("cbor")
 const fs = require("fs")
 const inquirer = require("inquirer")
 const merge = require("lodash.merge")
@@ -26,12 +27,21 @@ module.exports = {
         hint: "List available Witnet Radon assets.",
         params: "[RADON_ASSETS ...]",
         options: {
+          filter: {
+            hint: "Restrict output to name-matching assets.",
+          },
           legacy: {
             hint: "List only those declared in witnet/assets folder.",
           },
-          filter: {
-            hint: "Restrict output to name-matching assets.",
+          modals: {
+            hint: "Restrict output to Radon modals.",
+          },
+          requests: {
+            hint: "Restrict output to Radon requests.",
           },
+          templates: {
+            hint: "Restrict output to Radon templates.",
+          },          
         },
       },
       check: {
@@ -168,21 +178,25 @@ async function assets (options = {}, [...patterns]) {
     `${options?.module ? options.module.toUpperCase() : path.basename(process.cwd()).toUpperCase()} RADON ASSETS`,
     helpers.colors.white
   )
-  const assets = clearEmptyBranches(loadAssets(options), patterns, options?.filter)
+  const assets = clearEmptyBranches(
+    options?.module ? require(options.module) : loadAssets(options), 
+    patterns, 
+    options
+  );
   if (assets && Object.keys(assets).length > 0) {
-    traceWitnetArtifacts(assets, patterns, "  ", options?.filter)
+    traceWitnetArtifacts(assets, patterns, "  ", options)
   } else {
     console.info("> No custom Radon assets declared just yet.")
   }
 }
 /// -------------------------------------------------------------------------------------------------------------------
 
-async function check (options = {}) {
+async function check () {
   if (!isModuleInitialized) {
     throw new Error(`No Witnet Radon workspace has been initialized. Please, run ${white("npx witsdk radon init")} if willing to declare your own Radon assets.`)
   }
   try {
-    const assets = loadAssets({ ...options, legacy: true })
+    const assets = loadAssets({ legacy: true })
     const [
       modals,
       requests,
@@ -233,7 +247,7 @@ async function decode (options = {}, args = []) {
   } else {
     args = args.slice(1)
 
-    const assets = loadAssets(options)
+    const assets = options?.module ? require(options.module) : loadAssets(options)
     const headline = options?.headline
     const crafts = flattenRadonArtifacts(assets).filter(craft => craft.key.toLowerCase().indexOf(asset.toLowerCase()) >= 0)
     if (crafts.length === 0) {
@@ -244,11 +258,12 @@ async function decode (options = {}, args = []) {
       if (artifact instanceof Witnet.Radon.RadonRequest) {
         prefix = "RadonRequest::"
       } else if (artifact instanceof Witnet.Radon.RadonModal) {
-        artifact.providers = ["https://dummy"]
+        artifact.providers = [...args[0].split(";") || "https://dummy"]
         const modalArgs = []
-        let argIndex = 0
+        let argIndex = 1
         while (modalArgs.length < artifact.argsCount) {
-          modalArgs.push(`{:${++argIndex}}`)
+          modalArgs.push(args[argIndex] || `{:${argIndex}}`)
+          argIndex += 1
         }
         artifact = artifact.buildRadonRequest(modalArgs)
         prefix = "RadonModal::"
@@ -298,7 +313,7 @@ async function dryrun (options = {}, args = []) {
     }
   } else {
     args = args.slice(1)
-    const assets = loadAssets(options)
+    const assets = options?.module ? require(options.module) : loadAssets(options)
     const headline = options?.headline
     const crafts = flattenRadonArtifacts(assets).filter(craft => craft.key.toLowerCase().indexOf(asset.toLowerCase()) >= 0)
     if (crafts.length === 0) {
@@ -309,33 +324,48 @@ async function dryrun (options = {}, args = []) {
       if (artifact instanceof Witnet.Radon.RadonRequest) {
         prefix = "RadonRequest::"
       } else {
-        if (!artifact?.samples) {
-          console.error(`${artifact.constructor.name}::${key}: cannot dry-run if no sample parameters are declared.\n`)
-          continue
-        }
         let artifactArgs = []
-        if (options?.default) {
-          artifactArgs = Object.values(artifact.samples)[0]
-        } else {
-          const prompt = inquirer.createPromptModule()
-          const sample = await prompt([{
-            choices: Object.keys(artifact.samples),
-            message: `${artifact.constructor.name}::${key} args:`,
-            name: "key",
-            type: "list",
-          }])
-          artifactArgs = artifact.samples[sample.key]
-        }
         if (artifact instanceof Witnet.Radon.RadonModal) {
-          artifact.providers = artifactArgs.shift().split(";")
-          artifact = artifact.buildRadonRequest(artifactArgs)
+          if (args.length < artifact.argsCount) {
+            throw new Error(`missing parameters for Radon Modal.`)
+          } 
+          artifact.providers = [...args[0].split(";")]
+          const modalArgs = []
+          let argIndex = 1
+          while (modalArgs.length < artifact.argsCount) {
+            modalArgs.push(args[argIndex])
+            argIndex += 1
+          }
+          artifact = (
+            artifact.homogeneous 
+              ? artifact.buildRadonRequest(modalArgs)
+              : artifact.buildRadonRequest([ ...artifact.sources.map(source => modalArgs.slice(0, source.argsCount)) ])
+          )
           prefix = "RadonModal::"
-        } else if (artifact instanceof Witnet.Radon.RadonTemplate) {
-          artifact = artifact.buildRadonRequest(artifactArgs)
-          prefix = "RadonTemplate::"
-        } else if (artifact instanceof Witnet.Radon.RadonRetrieval) {
-          artifact = new Witnet.Radon.RadonRequest({ sources: artifact.foldArgs(artifactArgs) })
-          prefix = "RadonRetrieval::"
+        } else {
+          if (!artifact?.samples) {
+            console.error(`${artifact.constructor.name}::${key}: cannot dry-run if no sample parameters are declared.\n`)
+            continue
+          }
+          if (options?.default) {
+            artifactArgs = Object.values(artifact.samples)[0]
+          } else {
+            const prompt = inquirer.createPromptModule()
+            const sample = await prompt([{
+              choices: Object.keys(artifact.samples),
+              message: `${artifact.constructor.name}::${key} args:`,
+              name: "key",
+              type: "list",
+            }])
+            artifactArgs = artifact.samples[sample.key]
+          }
+          if (artifact instanceof Witnet.Radon.RadonTemplate) {
+            artifact = artifact.buildRadonRequest(artifactArgs)
+            prefix = "RadonTemplate::"
+          } else if (artifact instanceof Witnet.Radon.RadonRetrieval) {
+            artifact = new Witnet.Radon.RadonRequest({ sources: artifact.foldArgs(artifactArgs) })
+            prefix = "RadonRetrieval::"
+          }
         }
       }
       if (!headline) {
@@ -367,8 +397,12 @@ const stringifyReducer = (x, c) => {
 }
 
 function loadAssets (options) {
-  const { assets } = options?.module ? require(options.module) : (options?.legacy ? {} : require("@witnet/sdk"))
-  return isModuleInitialized && fs.existsSync(`${WITNET_ASSETS_PATH}`) ? merge(assets, require(`${WITNET_ASSETS_PATH}`)) : assets
+  const { assets } = options?.legacy ? {} : require("@witnet/sdk")
+  return (
+    isModuleInitialized && fs.existsSync(`${WITNET_ASSETS_PATH}`)
+      ? merge(assets, require(`${WITNET_ASSETS_PATH}`)) 
+      : assets
+  );
 }
 
 function flattenRadonArtifacts (tree, headers) {
@@ -395,44 +429,64 @@ function flattenRadonArtifacts (tree, headers) {
   return matches
 };
 
-function countWitnetArtifacts (assets, args, filter = false) {
+function countWitnetArtifacts (assets, args, options) {
   let counter = 0
   Object.entries(assets).forEach(([key, value]) => {
-    if ((
-      value instanceof Witnet.Radon.RadonModal ||
-                value instanceof Witnet.Radon.RadonRequest ||
-                value instanceof Witnet.Radon.RadonTemplate ||
-                value instanceof Witnet.Radon.RadonRetrieval
-    ) && (
-      !filter ||
-                !args ||
-                args.length === 0 ||
-                args.find(arg => key.toLowerCase().indexOf(arg.toLowerCase()) >= 0)
+    let include = (
+      (options?.modals && value instanceof Witnet.Radon.RadonModal)
+        || (options?.templates && value instanceof Witnet.Radon.RadonTemplate)
+        || (options?.retrievals && value instanceof Witnet.Radon.RadonRetrieval)
+        || (options?.requests && value instanceof Witnet.Radon.RadonRequest)
+    );
+    if (!(options?.modals || options?.templates || options?.retrievals || options?.requests)) {
+      include = (
+        value instanceof Witnet.Radon.RadonModal ||
+                  value instanceof Witnet.Radon.RadonRequest ||
+                  value instanceof Witnet.Radon.RadonTemplate ||
+                  value instanceof Witnet.Radon.RadonRetrieval
+      );
+    }
+    if (include && (
+      !options?.filter
+        || !args 
+        || args.length === 0 
+        || args.find(arg => key.toLowerCase().indexOf(arg.toLowerCase()) >= 0)
     )) {
       counter++
     } else if (typeof value === "object") {
-      counter += countWitnetArtifacts(value, args)
+      counter += countWitnetArtifacts(value, args, options)
     }
   })
   return counter
 }
 
-function clearEmptyBranches (node, args, filter) {
+function clearEmptyBranches (node, args, options) {
   if (node) {
     const assets = Object.fromEntries(
       Object.entries(node).map(([key, value]) => {
+        let include = (
+          (options?.modals && value instanceof Witnet.Radon.RadonModal)
+            || (options?.templates && value instanceof Witnet.Radon.RadonTemplate)
+            || (options?.retrievals && value instanceof Witnet.Radon.RadonRetrieval)
+            || (options?.requests && value instanceof Witnet.Radon.RadonRequest)
+        );
+        if (!(options?.modals || options?.templates || options?.retrievals || options?.requests)) {
+          include = (
+            value instanceof Witnet.Radon.RadonModal ||
+                      value instanceof Witnet.Radon.RadonRequest ||
+                      value instanceof Witnet.Radon.RadonTemplate ||
+                      value instanceof Witnet.Radon.RadonRetrieval
+          );
+        }
         if (
-          (!filter || args.find(arg => key.toLowerCase().indexOf(arg.toLowerCase()) >= 0)) && (
-            value instanceof Witnet.Radon.RadonRetrieval ||
-                        value instanceof Witnet.Radon.RadonModal ||
-                        value instanceof Witnet.Radon.RadonRequest ||
-                        value instanceof Witnet.Radon.RadonTemplate
+          include && (
+            !options?.filter || args.find(arg => key.toLowerCase().indexOf(arg.toLowerCase()) >= 0)
           )
         ) {
           return [key, value]
         } else if (typeof value === "object") {
-          if (countWitnetArtifacts(value, args, filter) > 0) {
-            return [key, clearEmptyBranches(value, args, filter)]
+          if (countWitnetArtifacts(value, args, options) > 0) {
+            return [key, clearEmptyBranches(value, args, options)]
           } else {
             return [key, undefined]
           }
@@ -450,25 +504,25 @@ function clearEmptyBranches (node, args, filter) {
   }
 }
 
-function traceWitnetArtifacts (assets, args, indent = "", filter = false) {
+function traceWitnetArtifacts (assets, args, indent = "", options) {
   const prefix = `${indent}`
   Object.keys(assets).forEach((key, index) => {
     const isLast = index === Object.keys(assets).length - 1
     const found = args.find(arg => key.toLowerCase().indexOf(arg.toLowerCase()) >= 0)
     const color = found ? helpers.colors.mcyan : helpers.colors.cyan
     if (assets[key] instanceof Witnet.Radon.RadonRequest) {
-      if (!filter || found) {
-        console.info(`${prefix}${color(key)}`)
+      if (!options?.filter || found) {
+        console.info(`${prefix}${color(key)} ${assets[key].sources.length > 1 ? helpers.colors.yellow(`(${assets[key].sources.length} sources)`) : ""}`)
         if (isLast) {
           console.info(`${prefix}`)
         }
       }
-    } else if (
+    } else if ((
       assets[key] instanceof Witnet.Radon.RadonTemplate ||
             assets[key] instanceof Witnet.Radon.RadonModal
-    ) {
+    )) {
       const argsCount = assets[key].argsCount
-      if (!filter || found) {
+      if (!options?.filter || found) {
         console.info(`${prefix}${color(key)} ${argsCount > 0 ? helpers.colors.green(`(${argsCount} args)`) : ""}`)
         if (isLast) {
           console.info(`${prefix}`)
@@ -476,15 +530,15 @@ function traceWitnetArtifacts (assets, args, indent = "", filter = false) {
       }
     } else if (assets[key] instanceof Witnet.Radon.RadonRetrieval) {
       const argsCount = assets[key].argsCount
-      if (!filter || found) {
+      if (!options?.filter || found) {
         console.info(`${prefix}${color(key)} ${argsCount > 0 ? helpers.colors.green(`(${argsCount} args)`) : ""}`)
         if (isLast) {
           console.info(`${prefix}`)
         }
       }
-    } else if (typeof assets[key] === "object" && countWitnetArtifacts(assets[key], args, filter) > 0) {
+    } else if (typeof assets[key] === "object" && countWitnetArtifacts(assets[key], args, options) > 0) {
       console.info(`${indent}${isLast ? "└─ " : "├─ "}${key}`)
-      traceWitnetArtifacts(assets[key], args, !isLast ? `${indent}│  ` : `${indent}   `, filter)
+      traceWitnetArtifacts(assets[key], args, !isLast ? `${indent}│  ` : `${indent}   `, options)
     }
   })
 }
@@ -617,6 +671,25 @@ async function traceWitnetRadonRequestDryRun (request, options) {
   const result = report?.aggregate.result
   const resultType = Object.keys(result)[0]
   const resultValue = Object.values(result)[0]
+  let resultSize 
+  const parseRadonResult = (value) => {
+    if (Array.isArray(value)) {
+      return value.map(item => parseRadonResult(item))
+    } if (typeof value === 'object') {
+      return parseRadonResult(Object.values(value)[0])
+    } else {
+      return JSON.parse(value);
+    }
+  }
+  switch (resultType) {
+    case "RadonBoolean": resultSize = 1; break;
+    case "RadonBytes": resultSize = cbor.encode(Uint8Array.from(resultValue)).byteLength - 2; break;
+    case "RadonInteger": case "RadonFloat": resultSize = cbor.encode(resultValue).byteLength; break;
+    case "RadonArray": case "RadonMap": 
+      const parsed = parseRadonResult(resultValue)
+      resultSize = cbor.encode(parsed).byteLength;
+      break;
+  }
   if (options?.json) {
     if (options?.verbose) {
       console.info(JSON.stringify(report, null, options?.indent ? " ".repeat(options.indent) : ""))
@@ -670,9 +743,6 @@ async function traceWitnetRadonRequestDryRun (request, options) {
       console.info(`${indent}   │ ${corner}─ [ ${color(authority)} ]`)
     }
     if (source.method !== Witnet.Radon.retrievals.Methods.RNG && options?.verbose) {
-      // const result = report.retrieve[sourceIndex].result
-      // const resultType = Object.keys(result)[0]
-      // const resultValue = JSON.stringify(Object.values(result)[0])
       console.info(
         `${indent}   │ ${sep}    > Request:        ${
           helpers.colors.mgreen(Witnet.Radon.retrievals.Methods[source.method].split(/(?=[A-Z])/).join("-").toUpperCase())
@@ -687,8 +757,8 @@ async function traceWitnetRadonRequestDryRun (request, options) {
       }
       const printData = (headline, data, color) => {
         const type = Object.keys(data)[0]
-        data = typeof data[type] === "object" || Array.isArray(data[type]) ? JSON.stringify(data[type]) : data[type]
-        const lines = data.match(/.{1,96}/g).slice(0, 256)
+        data = (typeof data[type] === "object" || typeof data[type] === "boolean" || Array.isArray(data[type]) ? JSON.stringify(data[type]) : data[type]) || ""
+        const lines = data.match(/.{1,96}/g)?.slice(0, 256) || [""]
         if (lines.length === 256) lines[255] += "..."
         const typeColor = (type === "RadonError") ? helpers.colors.red : helpers.colors.yellow
         const lineColor = (type === "RadonError") ? helpers.colors.gray : color
@@ -747,10 +817,15 @@ async function traceWitnetRadonRequestDryRun (request, options) {
       } │`
     )
   }
-  console.info(`${indent}│ Result size:    ${helpers.colors.cyan("xxx bytes")}${" ".repeat(flexbar.length + 13 - 9)} │`)
+  if (resultSize) {
+    console.info(`${indent}│ CBOR size:      ${
+      helpers.colors.cyan(`${resultSize} bytes`)
+      }${" ".repeat(flexbar.length + 7 - resultSize.toString().length)
+      } │`)
+  }
   console.info(`${indent}└────┬─────────────────────────${flexbar}─┘`)
   const printMapItem = (indent, width, key, value, indent2 = "") => {
-    if (key) key = `${indent2}"${key}": `
+    if (key) key = `${indent2}${key}: `
     else key = `${indent2}`
     let type = extractTypeName(Object.keys(value)[0])
     value = Object.values(value)[0]
@@ -774,14 +849,11 @@ async function traceWitnetRadonRequestDryRun (request, options) {
           }`
         )
       }
-      Object.entries(value).forEach(([key, value]) => printMapItem(indent, width, type === "Map" ? key : null, value, indent2 + " "))
+      Object.entries(value).forEach(([key, value]) => printMapItem(indent, width, type === "Map" ? key : null, helpers.unescapeSlashes(value), indent2 + " "))
     } else {
       if (key.length > width - 12) {
         console.info(`${indent}        ${helpers.colors.yellow(type)} ${" ".repeat(width - 15)}${helpers.colors.green("...")}`)
       } else {
-        if (["String", "Error"].includes(type)) {
-          value = JSON.stringify(value)
-        }
         type = `[ ${type}${" ".repeat(7 - type.length)} ]`
         const result = key + value
         // let spaces = width - 12 - result.length
@@ -789,7 +861,11 @@ async function traceWitnetRadonRequestDryRun (request, options) {
           value = value.slice(0, width - 15 - key.length) + "..."
           // spaces = 0
         }
-        console.info(`${indent}        ${helpers.colors.yellow(type)} ${helpers.colors.green(key)}${helpers.colors.mcyan(value)}`)
+        if (["String", "Error"].includes(type)) {
+          console.info(`${indent}        ${helpers.colors.yellow(type)} ${helpers.colors.green(key)}"${helpers.colors.mcyan(value)}"`)
+        } else {
+          console.info(`${indent}        ${helpers.colors.yellow(type)} ${helpers.colors.green(key)}${helpers.colors.mcyan(value)}`)
+        }
       }
     }
   }
@@ -803,10 +879,12 @@ async function traceWitnetRadonRequestDryRun (request, options) {
     } else {
       if (resultType === "Bytes") {
         resultValue = JSON.parse(resultValue).map(char => ("00" + char.toString(16)).slice(-2)).join("")
+      } else if (resultType === "Boolean") {
+        resultValue = JSON.stringify(resultValue)
       }
       const color = resultType.indexOf("Error") > -1 ? helpers.colors.gray : helpers.colors.lcyan
       const typeText = resultType.indexOf("Error") > -1 ? "\x1b[1;98;41m  Error  \x1b[0m" : helpers.colors.lyellow(`[ ${resultType} ]`)
-      const lines = resultValue.match(/.{1,96}/g).slice(0, 256)
+      const lines = resultValue.match(/.{1,96}/g)?.slice(0, 256) || [""]
       console.info(`${indent}     └─ ${typeText} ${color(lines[0])}`)
       lines.slice(1).forEach(line => {
         console.info(`${indent}             ${" ".repeat(resultType.length)}${color(line)}`)

package/src/bin/cli/wallet.js

@@ -528,7 +528,6 @@ async function resolve (options = {}, [pattern, ...args]) {
     throw Error("--from address not found in wallet")
   }
   const request = await _loadRadonRequest({ ...options, pattern, args })
-  // console.log(request)
   await helpers.traceTransaction(
     Witnet.DataRequests.from(ledger, request), {
       headline: "DATA REQUEST TRANSACTION",
@@ -947,13 +946,12 @@ async function _loadRadonRequest (options = {}) {
   }
 
   // load Radon assets from environment
-  let assets = utils.searchRadonAssets(
-    {
-      assets: loadAssets(options),
+  const assets = utils.searchRadonAssets({ 
+      assets: options?.module ? require(options.module) : loadAssets(options),
       pattern: options?.pattern,
-    },
+    }, 
     (key, pattern) => key.toLowerCase().indexOf(pattern.toLowerCase()) >= 0
-  )
+  );
 
   if (args.length > 0) {
     // ignore RadonRequests if args were passed from the CLI