@witnet/sdk 1.0.15 → 1.1.0

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")
@@ -244,11 +245,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::"
@@ -309,33 +311,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) {
@@ -458,7 +475,7 @@ function traceWitnetArtifacts (assets, args, indent = "", filter = false) {
     const color = found ? helpers.colors.mcyan : helpers.colors.cyan
     if (assets[key] instanceof Witnet.Radon.RadonRequest) {
       if (!filter || found) {
-        console.info(`${prefix}${color(key)}`)
+        console.info(`${prefix}${color(key)} ${assets[key].sources.length > 1 ? helpers.colors.yellow(`(${assets[key].sources.length} sources)`) : ""}`)
         if (isLast) {
           console.info(`${prefix}`)
         }
@@ -617,6 +634,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 +706,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 +720,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 +780,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 +812,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 +824,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 +842,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",

package/src/bin/helpers.js

@@ -369,8 +369,8 @@ function checkRpcWildcards (wildcards) {
   } else if (typeof wildcards === "string") {
     if (isWildcard(wildcards)) {
       const char = wildcards.charAt(1)
-      if (char < "1" || char > "9") {
-        throw Error("RPC: wildcards not in range [1 .. 9]")
+      if (char < "0" || char > "9") {
+        throw Error("RPC: wildcards not in range [0 .. 9]")
       }
     }
   }
@@ -392,10 +392,25 @@ function replaceWildcards (obj, args) {
       ? replaceWildcards(value, args)
       : value
     )
+  } else if (obj && typeof obj === "object") {
+    obj = replaceObjectWildcards(obj, args)
   }
   return obj
 }
 
+function replaceObjectWildcards(obj, args) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => {
+      for (let argIndex = 0; argIndex < args.length; argIndex ++) {
+        const wildcard = `\\${argIndex}\\`
+        key = key.replaceAll(wildcard, args[argIndex])
+        value = replaceWildcards(value, args)
+      }
+      return [key, value]
+    })
+  )
+}
+
 function spliceWildcard (obj, argIndex, argValue, argsCount) {
   if (obj && typeof obj === "string") {
     const wildcard = `\\${argIndex}\\`
@@ -716,7 +731,7 @@ function traceTransactionReceipt (receipt) {
       mblue(receipt.recipients.filter((pkh, index, array) => index === array.indexOf(pkh)))
     }`)
   }
-  if (receipt?.fees) console.info(` > Fee:          ${yellow(receipt.fees.toString(2))}`)
+  if (receipt?.fees) console.info(` > Network fee:  ${yellow(receipt.fees.toString(2))}`)
   if (receipt?.value) console.info(` > Value:        ${myellow(receipt.value.toString(2))}`)
   if (receipt?.weight) console.info(` > Weight:       ${mgreen(commas(receipt.weight))}`)
   if (receipt?.witnesses) {
@@ -771,6 +786,23 @@ async function traceTransaction (transmitter, options) {
   return receipt
 }
 
+function unescapeSlashes(str) {
+  // add another escaped slash if the string ends with an odd
+  // number of escaped slashes which will crash JSON.parse
+  let parsedStr = str.replace(/(^|[^\\])(\\\\)*\\$/, "$&\\");
+
+  // escape unescaped double quotes to prevent error with
+  // added double quotes in json string
+  parsedStr = parsedStr.replace(/(^|[^\\])((\\\\)*")/g, "$1\\$2");
+
+  try {
+    parsedStr = JSON.parse(`"${parsedStr}"`);
+  } catch(e) {
+    return str;
+  }
+  return parsedStr ;
+}
+
 module.exports = {
   colors: {
     bblue,
@@ -837,4 +869,5 @@ module.exports = {
   replaceWildcards,
   spliceWildcard,
   txJsonReplacer,
+  unescapeSlashes,
 }

package/src/bin/toolkit.js

@@ -18,7 +18,7 @@ const {
 
 /// CONSTANTS =======================================================================================================
 
-const version = "2.0.8"
+const version = "2.0.21"
 const toolkitDownloadUrlBase = `https://github.com/witnet/witnet-rust/releases/download/${version}/`
 const toolkitDownloadNames = {
   win32: (arch) => `witnet_toolkit-${arch}-pc-windows-msvc.exe`,

package/witnet/assets/modals/web3/eth.js

@@ -16,13 +16,13 @@ module.exports = {
   }),
   WitOracleEthGetBalance: new RadonModal({
     retrieval: retrievals.JsonRPC({
-      rpc: retrievals.rpc.eth.getBalance("\\1\\"),
+      rpc: retrievals.rpc.eth.getBalance("\\0\\"),
       script: RadonScript(types.RadonString).asFloat().floor(),
     }),
   }),
   WitOracleEthGetTransactionReceipt: new RadonModal({
     retrieval: retrievals.JsonRPC({
-      rpc: retrievals.rpc.eth.getTransactionByHash("\\1\\"),
+      rpc: retrievals.rpc.eth.getTransactionByHash("\\0\\"),
       script: RadonScript(types.RadonString).parseJSONMap(),
     }),
   }),

package/witnet/assets/modals/web3/ipfs.js

@@ -1,8 +1,6 @@
 const {
   RadonModal,
   RadonScript,
-  // filters,
-  // reducers,
   retrievals,
   types,
 } = require("../../../../src/lib/radon")
@@ -10,10 +8,15 @@ const {
 module.exports = {
     WitOracleIpfsFileExists: new RadonModal({
         retrieval: retrievals.HttpHead({
-            headers: {},
-            script: RadonScript(types.RadonString),
+            script: RadonScript(types.RadonMap)
+                .getString("etag")
+                .slice(1, -1)
+                .match(types.RadonBoolean, { "\\0\\": true }, false)
         }),
     }),
-    WitOracleIpfsFileSha256: {},
-    WitOracleIpfsFileSha256Sealed: {},
+    WitOracleIpfsFileSha256: new RadonModal({
+        retrieval: retrievals.HttpGet({
+            script: RadonScript(types.RadonBytes).hash()
+        })
+    })
 }

package/witnet/assets/modals/web3/wit.js

@@ -8,14 +8,14 @@ const {
 module.exports = {
   WitOracleWitGetBalance: new RadonModal({
     retrieval: retrievals.JsonRPC({
-      rpc: retrievals.rpc.wit.getBalance("\\1\\"),
+      rpc: retrievals.rpc.wit.getBalance("\\0\\"),
       script: RadonScript(types.RadonString).parseJSONMap().getMap("result").values(),
     }),
   }),
   WitOracleWitGetValueTransfer: new RadonModal({
     retrieval: retrievals.JsonRPC({
-      rpc: retrievals.rpc.wit.getValueTransfer("\\1\\", "\\2\\"),
-      script: RadonScript(types.RadonString).parseJSONMap().getMap("result").getMap("\\2\\").values(),
+      rpc: retrievals.rpc.wit.getValueTransfer("\\0\\", "\\1\\"),
+      script: RadonScript(types.RadonString).parseJSONMap().getMap("result").getMap("\\1\\").values(),
     }),
   }),
 }

package/witnet/assets/requests.js

@@ -8,38 +8,16 @@ const {
 } = require("../../src/lib/radon")
 
 module.exports = {
-
   defi: {
     tickers: {
       crypto: {
         WitOracleRequestPriceCryptoWitUsdt6: new RadonRequest({
           sources: [
             retrievals.HttpGet({
-              url: "https://api-cloud.bitmart.com/spot/v1/ticker?symbol=WIT_USDT",
-              script: RadonScript(types.RadonString)
-                .parseJSONMap()
-                .getMap("data")
-                .getArray("tickers")
-                .getMap(0)
-                .getFloat("last_price")
-                .multiply(1e6)
-                .round(),
-            }),
-            retrievals.HttpGet({
-              url: "https://data.gateapi.io/api2/1/ticker/wit_usdt",
-              script: RadonScript(types.RadonString)
-                .parseJSONMap()
-                .getFloat("last")
-                .multiply(1e6)
-                .round(),
-            }),
-            retrievals.HttpGet({
-              url: "https://www.mexc.com/open/api/v2/market/ticker?symbol=WIT_USDT",
+              url: "https://api.mexc.com/api/v3/ticker/price?symbol=WITUSDT",
               script: RadonScript(types.RadonString)
                 .parseJSONMap()
-                .getArray("data")
-                .getMap(0)
-                .getFloat("last")
+                .getFloat("price")
                 .multiply(1e6)
                 .round(),
             }),
@@ -50,35 +28,11 @@ module.exports = {
         WitOracleRequestPriceCryptoUsdtWit9: new RadonRequest({
           sources: [
             retrievals.HttpGet({
-              url: "https://api-cloud.bitmart.com/spot/v1/ticker?symbol=WIT_USDT",
-              script: RadonScript(types.RadonString)
-                .parseJSONMap()
-                .getMap("data")
-                .getArray("tickers")
-                .getMap(0)
-                .getFloat("last_price")
-                .power(-1)
-                .multiply(1e9)
-                .round(),
-            }),
-            retrievals.HttpGet({
-              url: "https://data.gateapi.io/api2/1/ticker/wit_usdt",
+              url: "https://api.mexc.com/api/v3/ticker/price?symbol=WITUSDT",
               script: RadonScript(types.RadonString)
                 .parseJSONMap()
-                .getFloat("last")
-                .power(-1)
-                .multiply(1e9)
-                .round(),
-            }),
-            retrievals.HttpGet({
-              url: "https://www.mexc.com/open/api/v2/market/ticker?symbol=WIT_USDT",
-              script: RadonScript(types.RadonString)
-                .parseJSONMap()
-                .getArray("data")
-                .getMap(0)
-                .getFloat("last")
-                .power(-1)
-                .multiply(1e9)
+                .getFloat("price")
+                .multiply(1e6)
                 .round(),
             }),
           ],