@witnet/sdk 1.0.0-beta.5 → 1.0.1

package/src/bin/cli/radon.js

@@ -128,7 +128,7 @@ module.exports = {
         },
       },
       init: {
-        hint: "Initialize Witnet Radon workspace within your project.",
+        hint: "Initialize a Witnet Radon workspace in this project.",
       },
     },
   subcommands: {
@@ -543,7 +543,7 @@ function traceWitnetRadonRequest (request, options) {
           }`
         )
         console.info(`${indent}   │ ${sep}    > URL query:      ${helpers.colors.green(source.url)}`)
-        if (source?.headers && source?.headers.length > 0) {
+        if (source?.headers) { 
           console.info(`${indent}   │ ${sep}    > HTTP headers:   ${helpers.colors.green(JSON.stringify(source.headers))}`)
         }
         if (source?.body) {
@@ -677,7 +677,7 @@ async function traceWitnetRadonRequestDryRun (request, options) {
         }`
       )
       console.info(`${indent}   │ ${sep}    > URL query:      ${helpers.colors.green(source.url)}`)
-      if (source?.headers && source?.headers.length > 0) {
+      if (source?.headers) {
         console.info(`${indent}   │ ${sep}    > HTTP headers:   ${helpers.colors.green(JSON.stringify(source.headers))}`)
       }
       if (source?.body) {

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",
@@ -195,15 +223,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 +339,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 +349,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))}`)
@@ -705,7 +799,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],
         }
@@ -780,7 +874,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"]

package/src/bin/helpers.js

@@ -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

@@ -11,13 +11,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"),
+      script: RadonScript(types.RadonString).parseJSONMap().getMap("result").getMap("Simple").values(),
     }),
   }),
 }

package/witnet/assets/requests.js

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