@witnet/sdk 1.0.0-beta.5 → 1.0.3

package/src/bin/cli/wallet.js

@@ -63,6 +63,10 @@ module.exports = {
       hint: "List wallet's HD-accounts treasuring staked, locked or unlocked Wits.",
       params: ["[WIT_ADDRESSES ...]"],
       options: {
+        ethereum: {
+          hint: "Generate account ownership proofs verifiable in Ethereum networks.",
+          param: "EVM_ADDRESS"
+        },
         limit: {
           hint: "Max number of HD-accounts to derive.",
           param: "LIMIT",
@@ -97,7 +101,7 @@ module.exports = {
         },
       },
     },
-    decipher: {
+    decipherMasterKey: {
       hint: "Decipher some master key as exported from myWitWallet.",
     },
     delegatees: {
@@ -125,6 +129,30 @@ module.exports = {
     provider: {
       hint: "Show the underlying Wit/Oracle RPC provider being used.",
     },
+    signMessage: {
+      hint: "Prove ownership of a wallet address by signing some given message.",
+      param: "TEXT",
+      options: {
+        signer: {
+          hint: "Wallet's signer address other than wallet's default.",
+          param: "WALLET_ADDRESS",
+        },
+      },
+    },
+    verifyMessage: {
+      hint: "Verify authenticity of some given message and signature.",
+      param: "TEXT",
+      options: {
+        publicKey: {
+          hint: "Hexified public key of the alleged signer of the message.",
+          param: "<HEX_STRING>",
+        },
+        signature: {
+          hint: "Hexified signature produced with the signer's private key.",
+          param: "<HEX_STRING>",
+        },
+      },
+    },
     stake: {
       hint: "Stake specified amount of Wits by using some given authorization code.",
       params: "AUTH_CODE",
@@ -148,6 +176,10 @@ module.exports = {
           hint: "Recipient address.",
           param: "WIT_ADDRESS",
         },
+        metadata: {
+          hint: "Optional 20-byte metadata info.",
+          param: "HEX_STRING"
+        },
         value: {
           hint: "Amount in Wits to be transfered (e.g. `0.5` Wits).",
           param: "WITS | `all`",
@@ -163,6 +195,10 @@ module.exports = {
           param: "WALLET_ADDRESS",
         },
         join: { hint: "Join selected UTXOs together into a single UTXO (requires --value)." },
+        limit: {
+          hint: "Max number of HD-accounts to derive.",
+          param: "LIMIT",
+        },
         splits: {
           hint: "Number of UTXOs to split the target balance into (max: 50; requires --value).",
           param: "NUMBER",
@@ -195,15 +231,70 @@ module.exports = {
     },
   },
   subcommands: {
-    accounts, coinbase, decipher, delegatees: validators, notarize: resolve, provider, stake, transfer, withdraw: unstake, utxos,
+    accounts, coinbase, delegatees: validators, 
+    notarize: resolve, stake, transfer, withdraw: unstake, utxos, 
+    decipherMasterKey: decipher, provider, 
+    signMessage, verifyMessage,
   },
 }
 
 /// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /// CLI SUBMODULE COMMANDS ============================================================================================
 
+async function signMessage (options = {}, [...words]) {
+  const wallet = await _loadWallet({ 
+    ...options,
+    limit: 1,
+    "no-funds": true,
+  })
+  if (!words.length) {
+    throw Error(`some message must be entered.`)
+  }
+  const text = words.join(" ")
+  let ledger
+  if (options?.signer) {
+    ledger = options.signer === wallet.coinbase.pkh ? wallet.coinbase : wallet.getAccount(options.signer)
+  } else {
+    ledger = wallet
+  }
+  if (!ledger) {
+    throw Error(`no private key available for signer address ${options?.signer}`)
+  }
+  console.info(ledger.getSigner().signMessage(text))
+}
+
+async function verifyMessage (options = {}, [...words]) {
+  if (!words.length) {
+    throw Error(`some text must be entered.`)
+  }
+  const text = words.join(" ")
+  const digest = utils.digestMessage(text)
+  let { publicKey, signature } = options
+  if (!publicKey) {
+    throw Error(`--publicKey must be specified.`)
+  } else if (!signature) {
+    throw Error(`--signature must be specified`)
+  }
+  if (publicKey.startsWith("0x")) publicKey = publicKey.slice(2);
+  if (signature.startsWith("0x")) signature = signature.slice(2);
+  console.info(`Message:   "${text}"`)
+  console.info(`Digest:     ${utils.toHexString(digest)}`)
+  console.info(`Public key: ${publicKey}`)
+  console.info(`Signature:  ${signature}`)
+  console.info("-".repeat(120))
+  if (utils.ecdsaVerify(digest, publicKey, signature.slice(2))) {
+    console.info(
+      `^ Signed by ${
+        Witnet.PublicKey.fromUint8Array(utils.fromHexString(publicKey)).hash().toBech32("mainnet")
+      }.\n^ Message is authentic.`
+    );
+  } else {
+    console.error(`^ Invalid signature.`)
+  }
+}
+
 async function accounts (options = {}, args = []) {
-  const { verbose } = options
+  const { ethereum, verbose } = options
 
   let wallet
   if (args.length === 0) {
@@ -256,6 +347,9 @@ async function accounts (options = {}, args = []) {
           balance.unlocked > 0 ? colors.mmagenta(account.pkh) : colors.magenta(account.pkh),
           utxos.length,
           balance,
+          ...(ethereum ? [ 
+            account.getSigner().authorizeEvmAddress(ethereum), 
+          ] : [])
         ]
       }),
     )
@@ -263,45 +357,53 @@ async function accounts (options = {}, args = []) {
 
   let unlocked = 0n
   helpers.traceTable(
-    records.map(([index, pkh, count, balance]) => {
+    records.map(([index, pkh, count, balance, signature]) => {
       unlocked += balance.unlocked
       return [
-        index,
-        pkh,
-        count,
-        ...(verbose
-          ? [
-            Witnet.Coins.fromNanowits(balance.locked).wits.toFixed(2),
-            Witnet.Coins.fromNanowits(balance.staked).wits.toFixed(2),
-            Witnet.Coins.fromNanowits(balance.unlocked).wits.toFixed(2),
-            utils.totalCoins(balance).wits.toFixed(2),
-          ]
-          : [
-            Witnet.Coins.fromNanowits(balance.unlocked).wits.toFixed(2),
-          ]
+        index, pkh, 
+        ...(ethereum ? [ signature ] : (
+          verbose
+            ? [
+              count,
+              Witnet.Coins.fromNanowits(balance.locked).wits.toFixed(2),
+              Witnet.Coins.fromNanowits(balance.staked).wits.toFixed(2),
+              Witnet.Coins.fromNanowits(balance.unlocked).wits.toFixed(2),
+              utils.totalCoins(balance).wits.toFixed(2),
+            ]
+            : [
+              count,
+              Witnet.Coins.fromNanowits(balance.unlocked).wits.toFixed(2),
+            ]
+          )
         ),
       ]
     }), {
       headlines: [
-        "INDEX", `:WALLET ${wallet.network.toUpperCase()} ACCOUNTS`, 
-        "# UTXOs",
-        ...(verbose
-          ? ["Locked ($WIT)", "Staked ($WIT)", "Available ($WIT)", "BALANCE ($WIT)"]
-          : ["Available ($WIT)"]
-        ),
+        "INDEX", `:WITNET WALLET ${wallet.network.toUpperCase()} ACCOUNTS`,
+        ...(ethereum ? [`ETHEREUM ${wallet.network.toUpperCase()} WRAPPING AUTHORIZATION CODE [${ethereum}]`] : (
+          verbose
+            ? ["# UTXOS", "Locked ($WIT)", "Staked ($WIT)", "Available ($WIT)", "BALANCE ($WIT)"]
+            : ["# UTXOS", "Available ($WIT)"]
+          )
+        )
       ],
       humanizers: [
         helpers.commas,, 
-        helpers.commas, helpers.commas, helpers.commas, helpers.commas, helpers.commas,
+        ...(ethereum 
+          ? [,] 
+          : [helpers.commas, helpers.commas, helpers.commas, helpers.commas, helpers.commas]
+        ),
       ],
       colors: [
         ,, 
-        ...(verbose
-          ? [colors.white, colors.gray, colors.yellow, colors.myellow, colors.lyellow]
-          : [colors.white, colors.myellow]
+        ...(ethereum ? [colors.mblue, colors.gray] : (
+          verbose
+            ? [colors.white, colors.gray, colors.yellow, colors.myellow, colors.lyellow]
+            : [colors.white, colors.myellow]
+          )
         ),
       ],
-      maxColumnWidth: 48,
+      maxColumnWidth: 132,
     }
   )
   console.info(`^ Available balance: ${colors.lyellow(whole_wits(unlocked, 2))}`)
@@ -516,15 +618,26 @@ async function transfer (options = {}) {
     available = balance.unlocked
   }
 
+  // validate metadata info, if specified
+  let metadata
+  if (options?.metadata) {
+    if (!utils.isHexStringOfLength(options.metadata, 20)) {
+      throw Error(`--metadata must be a 20-byte hex string`)
+    }
+    metadata = Witnet.PublicKeyHash.fromHexString(options.metadata).toBech32(wallet.network)
+  }
+
   // validate recipient address
   if (!options?.into) {
     throw Error("--into address must be specified")
   }
   const into = Witnet.PublicKeyHash.fromBech32(options?.into).toBech32(wallet.network)
-
+  
   // determine transfer params
   const params = await _loadTransactionParams({ ...options })
-  const coins = params?.value === "all" ? Witnet.Coins.fromPedros(available - params.fees.pedros) : Witnet.Coins.fromWits(params?.value)
+  const coins = params?.value === "all" 
+    ? Witnet.Coins.fromPedros(BigInt(available - params.fees.pedros - BigInt(options?.metadata ? 1: 0))) 
+    : Witnet.Coins.fromWits(params?.value)
   if (available < coins.pedros) {
     throw Error(`Insufficient funds ${options?.from ? `on address ${options.from}.` : "on wallet."}`)
   } else if (params?.fees && coins.pedros <= params.fees.pedros) {
@@ -532,12 +645,15 @@ async function transfer (options = {}) {
   }
 
   // transfer value
+  const recipients = options?.metadata
+    ? [[into, coins], [metadata, Witnet.Coins.fromPedros(1n)]]
+    : [[into, coins]]
   await helpers.traceTransaction(
     Witnet.ValueTransfers.from(ledger), {
       headline: "VALUE TRANSFER TRANSACTION",
       color: colors.bblue,
       ...params,
-      recipients: [[into, coins]],
+      recipients,
     }
   )
 }
@@ -691,9 +807,10 @@ async function utxos (options = {}) {
   }
   const utxos = await ledger.selectUtxos({ value })
   const covered = utxos.map(utxo => BigInt(utxo.value))?.reduce((prev, curr) => prev + curr, 0n) || 0n
-  if (value && covered < value.pedros) {
-    throw Error(`Insufficient unlocked UTXOs in ${options?.from ? `wallet account ${ledger.pkh}` : "wallet"}`)
-  }
+  // if (value && covered < value.pedros) {
+  //   console.log(value, covered)
+  //   throw Error(`Insufficient unlocked UTXOs in ${options?.from ? `wallet account ${ledger.pkh}` : "wallet"}`)
+  // }
 
   // only if at least one utxo is selected, proceed with report and other operations, if any
   if (utxos.length > 0) {
@@ -705,7 +822,7 @@ async function utxos (options = {}) {
           utxo?.internal ? colors.green(utxo.output_pointer) : colors.mgreen(utxo.output_pointer),
           utxo.value,
         ]), {
-          headlines: ["INDEX", `WALLET ${wallet.network.toUpperCase()} ADDRESSES`, ":Unlocked UTXO pointers", "UTXO value ($pedros)"],
+          headlines: ["INDEX", `WITNET WALLET ${wallet.network.toUpperCase()} ADDRESSES`, ":Unlocked UTXO pointers", "UTXO value ($pedros)"],
           humanizers: [helpers.commas,,, helpers.commas],
           colors: [,,, colors.myellow],
         }
@@ -722,7 +839,7 @@ async function utxos (options = {}) {
         value,
       ]]
       await helpers.traceTransaction(valueTransfer, {
-        headline: `JOINING UTXOs: ${utxos.length} -> ${coins.pedros < covered ? 2 : 1}`,
+        headline: `JOINING UTXOs: ${utxos.length} -> ${value.pedros < covered ? 2 : 1}`,
         ...params,
         await: params?.await || options?.splits !== undefined,
         recipients,
@@ -734,11 +851,11 @@ async function utxos (options = {}) {
       if (splits > 50) {
         throw Error("Not possible to split into more than 50 UTXOs")
       }
-      value = Witnet.Coins.fromPedros(BigInt(Math.floor(value.pedros / splits)))
-      recipients.push(...Array(splits).fill([into, coins]))
+      value = Witnet.Coins.fromPedros(BigInt(Math.floor(Number(value.pedros) / splits)))
+      recipients.push(...Array(splits).fill([into, value]))
       await helpers.traceTransaction(
         valueTransfer, {
-          headline: `SPLITTING UTXOs: ${utxos.length} -> ${coins.pedros * splits < covered ? splits + 1 : splits}`,
+          headline: `SPLITTING UTXOs: ${utxos.length} -> ${Number(value.pedros) * splits < covered ? splits + 1 : splits}`,
           ...params,
           recipients,
           reload: options?.join,
@@ -780,7 +897,7 @@ async function validators (options = {}) {
       }), {
         headlines: [
           // "INDEX",
-          coinbase ? "WALLET COINBASE" : `WALLET ${wallet.network.toUpperCase()} ACCOUNTS`,
+          coinbase ? "WITNET WALLET COINBASE" : `WITNET WALLET ${wallet.network.toUpperCase()} ACCOUNTS`,
           "STAKE DELEGATEES",
           ...(verbose
             ? ["Nonce", "LW_Epoch", "LM_Epoch"]
@@ -814,16 +931,16 @@ async function validators (options = {}) {
 
 async function _loadRadonRequest (options = {}) {
   const args = options?.args || []
-  // TODO:
+  if (options?.pattern && typeof options.pattern === 'string' && utils.isHexString(options.pattern)) {
   // if (options?.pattern && typeof options.pattern === 'string' && utils.isHexString(options.pattern)) {
   //     if (utils.isHexStringOfLength(options.pattern, 32)) {
   //         throw `Searching RADON_BYTECODE by RAD_HASH not yet supported.`
-  //     } else try {
-  //         return Witnet.RadonRequest.fromHexString(pattern)
-  //     } catch {
-  //         throw `Invalid RADON_BYTECODE.`
-  //     }
-  // }
+      try {
+          return Witnet.Radon.RadonRequest.fromBytecode(options.pattern)
+      } catch (e) {
+          throw Error(`Invalid RADON_BYTECODE: ${e}`)
+      }
+  }
 
   // load Radon assets from environment
   let assets = utils.searchRadonAssets(

package/src/bin/helpers.js

@@ -347,7 +347,7 @@ function showVersion () {
 
 function getWildcardsCountFromString (str) {
   let maxArgsIndex = 0
-  if (str) {
+  if (str && typeof str === 'string') {
     let match
     const regexp = /\\\d\\/g
     while ((match = regexp.exec(str)) !== null) {
@@ -433,6 +433,16 @@ function toUpperCamelCase (str) {
   }).replace(/\s+/g, "")
 }
 
+function toUtf16Bytes(str) {
+  const bytes = new Uint8Array(str.length * 2);
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    bytes[i * 2] = code >> 8;
+    bytes[i * 2 + 1] = code & 0xff;
+  }
+  return bytes;
+}
+
 function toUtf8Array (str) {
   const utf8 = []
   for (let i = 0; i < str.length; i++) {
@@ -809,7 +819,8 @@ module.exports = {
   showVersion,
   toolkitRun,
   toUpperCamelCase,
-  toUtf8Array,
+  toUtf16Bytes,
+  toUtf8Array,  
   utf8ArrayToStr,
   prompt,
   prompter,

package/witnet/assets/modals/index.js

@@ -1,25 +1,9 @@
-const {
-  RadonModal,
-  RadonScript,
-  retrievals,
-  types,
-} = require("../../../src/lib/radon")
-
 module.exports = {
-  web: {
-    WitOracleWebFileExists: new RadonModal({
-      retrieval: retrievals.HttpHead({
-        headers: {},
-        script: RadonScript(types.RadonString),
-      }),
-    }),
-    WitOracleWebFileSha256: {},
-    WitOracleWebFileSha256Sealed: {},
-  },
   web3: {
     // btc: require("./web3/btc"),
     eth: require("./web3/eth.js"),
     // sol: require("./web3/sol"),
+    ipfs: require("./web3/ipfs.js"),
     wit: require("./web3/wit.js"),
   },
 }

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

@@ -0,0 +1,19 @@
+const {
+  RadonModal,
+  RadonScript,
+  // filters,
+  // reducers,
+  retrievals,
+  types,
+} = require("../../../../src/lib/radon")
+
+module.exports = {
+    WitOracleIpfsFileExists: new RadonModal({
+        retrieval: retrievals.HttpHead({
+            headers: {},
+            script: RadonScript(types.RadonString),
+        }),
+    }),
+    WitOracleIpfsFileSha256: {},
+    WitOracleIpfsFileSha256Sealed: {},
+}

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

@@ -1,8 +1,6 @@
 const {
   RadonModal,
   RadonScript,
-  // filters,
-  // reducers,
   retrievals,
   types,
 } = require("../../../../src/lib/radon")
@@ -11,13 +9,13 @@ module.exports = {
   WitOracleWitGetBalance: new RadonModal({
     retrieval: retrievals.JsonRPC({
       rpc: retrievals.rpc.wit.getBalance("\\1\\"),
-      script: RadonScript(types.RadonString).asFloat().floor(),
+      script: RadonScript(types.RadonString).parseJSONMap().getMap("result").values(),
     }),
   }),
-  WitOracleWitGetTransaction: new RadonModal({
+  WitOracleWitGetValueTransfer: new RadonModal({
     retrieval: retrievals.JsonRPC({
-      rpc: retrievals.rpc.wit.getTransaction("\\1\\"),
-      script: RadonScript(types.RadonString).parseJSONMap().getMap("result"),
+      rpc: retrievals.rpc.wit.getValueTransfer("\\1\\", "\\2\\"),
+      script: RadonScript(types.RadonString).parseJSONMap().getMap("result").getMap("\\2\\").values(),
     }),
   }),
 }

package/witnet/assets/requests.js

@@ -8,6 +8,7 @@ const {
 } = require("../../src/lib/radon")
 
 module.exports = {
+
   defi: {
     tickers: {
       crypto: {