15 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/routes/api/utils/auth/rpcAuth.js:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2019, Amalie Due Jensen
16 | 
22 |
25 |
22 | Another Verus Desktop instance is already running!
23 | Please close all other instances and restart the app.
24 |
15 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/routes/api/eth/coins.js:
--------------------------------------------------------------------------------
1 | const { ETH_HOMESTEAD } = require('../utils/constants/eth_networks');
2 | const createInterface = require('../utils/web3/provider');
3 |
4 | module.exports = (api) => {
5 | api.setPost('/eth/coins/activate', (req, res, next) => {
6 | const { chainTicker, network } = req.body;
7 |
8 | try {
9 | if (chainTicker && chainTicker === 'ETH') {
10 | if (api.eth.interface == null) {
11 | api.eth.interface = createInterface(
12 | network == null ? ETH_HOMESTEAD : network
13 | );
14 |
15 | const retObj = {
16 | msg: 'success',
17 | result: 'true',
18 | };
19 | res.send(JSON.stringify(retObj));
20 | } else {
21 | const retObj = {
22 | msg: 'error',
23 | result: 'ETH already active!',
24 | };
25 | res.send(JSON.stringify(retObj));
26 | }
27 | } else {
28 | const retObj = {
29 | msg: 'error',
30 | result: 'cannot activate non-eth coin on ETH network',
31 | };
32 | res.send(JSON.stringify(retObj));
33 | }
34 | } catch(e) {
35 | const retObj = {
36 | msg: 'error',
37 | result: e.message,
38 | };
39 | res.send(JSON.stringify(retObj));
40 | }
41 | });
42 |
43 | api.setPost('/eth/remove_coin', (req, res) => {
44 | api.eth.interface = null
45 |
46 | const retObj = {
47 | msg: 'success',
48 | result: true,
49 | };
50 |
51 | res.send(JSON.stringify(retObj));
52 | });
53 |
54 | return api;
55 | };
--------------------------------------------------------------------------------
/routes/api/eth/balances.js:
--------------------------------------------------------------------------------
1 | const ethers = require('ethers');
2 |
3 | module.exports = (api) => {
4 | api.setGet("/eth/get_balances", async (req, res, next) => {
5 | try {
6 | res.send(
7 | JSON.stringify({
8 | msg: "success",
9 | result: {
10 | native: {
11 | public: {
12 | //TODO: Return string instead
13 | confirmed: Number(ethers.formatEther(
14 | await api.eth.get_wallet_balance()
15 | )),
16 | unconfirmed: null,
17 | immature: null,
18 | interest: null,
19 | },
20 | private: {
21 | confirmed: null,
22 | },
23 | },
24 | reserve: {},
25 | },
26 | })
27 | );
28 | } catch (e) {
29 | res.send(
30 | JSON.stringify({
31 | msg: "error",
32 | result: e.message,
33 | })
34 | );
35 | }
36 | });
37 |
38 | api.eth.get_address_balance = async (address) => {
39 | if (api.eth.interface != null) {
40 | return api.eth.interface.DefaultProvider.getBalance(address)
41 | } else {
42 | throw new Error("Cannot get balance for inactive coin ETH")
43 | }
44 | }
45 |
46 | api.eth.get_wallet_balance = async () => {
47 | if (api.eth.wallet != null) {
48 | return await api.eth.get_address_balance(api.eth.wallet.address)
49 | } else {
50 | throw new Error("No wallet authenticated, cannot get wallet balance for ETH")
51 | }
52 | }
53 |
54 | return api;
55 | };
--------------------------------------------------------------------------------
/routes/preloads/plugin/preload-builtin.js:
--------------------------------------------------------------------------------
1 | const {
2 | contextBridge,
3 | shell,
4 | ipcRenderer
5 | } = require("electron");
6 | const fs = require('fs')
7 | const os = require('os')
8 | const url = require('url')
9 |
10 | const generateOpenExternalSafe = require('../../workers/openExternalSafe')
11 | const arch = require('arch');
12 | const chainParams = require("../../chainParams")
13 | const assetChainPorts = require("../../ports")
14 | const version = require('../../../version.json');
15 | const { pathsAgama } = require("../../api/pathsUtil");
16 | const appConfig = require("../../appConfig").config
17 |
18 | let apiShell = {}
19 | pathsAgama(apiShell, os.platform() === "win32" ? process.env.APPDATA : process.env.HOME)
20 |
21 | contextBridge.exposeInMainWorld("bridge", {
22 | getConfigSync: () =>
23 | JSON.parse(
24 | fs.readFileSync(`${apiShell.paths.agamaDir}/config.json`, "utf8")
25 | ),
26 | getSecretSync: () => JSON.parse(fs.readFileSync(`${apiShell.paths.agamaDir}/builtinsecret.json`, "utf8")).data,
27 | defaultConfig: appConfig,
28 | shell: {
29 | openExternal: generateOpenExternalSafe(shell, url),
30 | },
31 | assetChainPorts,
32 | appBasicInfo: {
33 | name: "Verus Desktop",
34 | mode: global.USB_MODE ? "usb" : "standard",
35 | version: version.version,
36 | },
37 | arch: arch(),
38 | chainParams
39 | });
40 |
41 | ipcRenderer.on('ipc', (_, msg) => {
42 | try {
43 | if (msg.type === 'response' || msg.type === 'push'|| msg.type === 'init') {
44 | window.postMessage(JSON.stringify(msg), '*');
45 | }
46 | } catch (err) {
47 | console.error(err);
48 | }
49 | });
--------------------------------------------------------------------------------
/routes/api/eth/addresses.js:
--------------------------------------------------------------------------------
1 | const { ethers } = require("ethers");
2 |
3 | module.exports = (api) => {
4 | api.eth.get_address = () => {
5 | if (api.eth.wallet != null) {
6 | return api.eth.wallet.address
7 | } else {
8 | throw new Error("No wallet authenticated, cannot get wallet address for ETH")
9 | }
10 | };
11 |
12 | api.eth.get_addresses = async () => {
13 | return {
14 | public: [{
15 | address: api.eth.get_address(),
16 | tag: "eth",
17 | balances: {
18 | native: ethers.formatEther(await api.eth.get_wallet_balance()),
19 | reserve: {}
20 | }
21 | }],
22 | private: []
23 | }
24 | };
25 |
26 | api.setGet('/eth/get_addresses', (req, res, next) => {
27 | api.eth.get_addresses()
28 | .then((addresses) => {
29 | const retObj = {
30 | msg: 'success',
31 | result: addresses,
32 | };
33 |
34 | res.send(JSON.stringify(retObj));
35 | })
36 | .catch(error => {
37 | const retObj = {
38 | msg: 'error',
39 | result: error.message,
40 | };
41 |
42 | res.send(JSON.stringify(retObj));
43 | })
44 | });
45 |
46 | api.setPost('/eth/get_privkey', (req, res, next) => {
47 | if (api.eth.wallet != null) {
48 | res.send(JSON.stringify({
49 | msg: 'success',
50 | result: api.eth.wallet.signer.signingKey.privateKey,
51 | }));
52 | } else {
53 | res.send(JSON.stringify({
54 | msg: 'error',
55 | result: `No ETH privkey found`
56 | }));
57 | }
58 | }, true);
59 |
60 | return api;
61 | };
--------------------------------------------------------------------------------
/routes/api/plugin/builtin/authenticator.js:
--------------------------------------------------------------------------------
1 | const { pushMessage } = require('../../../ipc/ipc');
2 | const { ReservedPluginTypes } = require('../../utils/plugin/builtin');
3 |
4 | module.exports = (api) => {
5 | api.authenticator = {}
6 |
7 | api.authenticator.authenticate = async (chainTicker, mode, originAppId, originBuiltin) => {
8 | return new Promise((resolve, reject) => {
9 | try {
10 | api.startPlugin(ReservedPluginTypes.VERUS_DESKTOP_AUTHENTICATOR, true, (data = {authorized: false}) => {
11 | resolve(data)
12 | }, (pluginWindow) => {
13 | pushMessage(pluginWindow, {
14 | ticker: chainTicker,
15 | mode: mode,
16 | origin_app_info: {
17 | id: originAppId,
18 | search_builtin: originBuiltin
19 | },
20 | launch_config: {}
21 | }, "VERUS_DESKTOP_AUTHENTICATOR_COIN_REQUEST")
22 | }, 630, 350, false)
23 | } catch(e) {reject(e)}
24 | })
25 | }
26 |
27 | api.setPost('/plugin/builtin/authenticator/authenticate', async (req, res, next) => {
28 | const { chainTicker, mode } = req.body
29 | const { app_id, builtin } = req.api_header
30 |
31 | try {
32 | const retObj = {
33 | msg: 'success',
34 | result: await api.authenticator.authenticate(chainTicker, mode, app_id, builtin),
35 | };
36 |
37 | res.send(JSON.stringify(retObj));
38 | } catch (e) {
39 | const retObj = {
40 | msg: 'error',
41 | result: e.message,
42 | };
43 |
44 | res.send(JSON.stringify(retObj));
45 | }
46 | });
47 |
48 | return api;
49 | };
--------------------------------------------------------------------------------
/routes/api/utils/plugin/builtin.js:
--------------------------------------------------------------------------------
1 | const path = require('path')
2 |
3 | const ReservedPluginTypes = {
4 | VERUS_DESKTOP_MAIN: "VERUS_DESKTOP_MAIN",
5 | VERUS_DESKTOP_AUTHENTICATOR: "VERUS_DESKTOP_AUTHENTICATOR",
6 | VERUS_LOGIN_CONSENT_UI: "VERUS_LOGIN_CONSENT_UI",
7 | VERUS_PBAAS_VISUALIZER: "VERUS_PBAAS_VISUALIZER"
8 | }
9 |
10 | // Builtin plugins have access to all permissions by default
11 | const BuiltinPlugins = {
12 | [ReservedPluginTypes.VERUS_DESKTOP_MAIN]: {
13 | name: "Verus Desktop",
14 | devPort: 3000
15 | },
16 | [ReservedPluginTypes.VERUS_DESKTOP_AUTHENTICATOR]: {
17 | name: "Authenticator",
18 | path: path.join(
19 | __dirname,
20 | "../",
21 | "../",
22 | "../",
23 | "../",
24 | "assets",
25 | "plugins",
26 | "builtin",
27 | "verus-desktop-authenticator"
28 | ),
29 | devPort: 3001
30 | },
31 | [ReservedPluginTypes.VERUS_LOGIN_CONSENT_UI]: {
32 | name: "VerusID Authentication",
33 | path: path.join(
34 | __dirname,
35 | "../",
36 | "../",
37 | "../",
38 | "../",
39 | "assets",
40 | "plugins",
41 | "builtin",
42 | "verus-login-consent-client"
43 | ),
44 | devPort: 3001
45 | },
46 | [ReservedPluginTypes.VERUS_PBAAS_VISUALIZER]: {
47 | name: "Visualizer",
48 | path: path.join(
49 | __dirname,
50 | "../",
51 | "../",
52 | "../",
53 | "../",
54 | "assets",
55 | "plugins",
56 | "builtin",
57 | "verus-pbaas-visualizer"
58 | ),
59 | devPort: 3003
60 | }
61 | };
62 |
63 | module.exports = {
64 | BuiltinPlugins,
65 | ReservedPluginTypes
66 | }
--------------------------------------------------------------------------------
/routes/api/native/getBlock.js:
--------------------------------------------------------------------------------
1 | module.exports = (api) => {
2 | /**
3 | * Gets a block given a height.
4 | *
5 | * @param {String} coin The chainTicker of the coin to make the call on
6 | * @param {String} hashorheight The block hash or height
7 | * @param {String} verbosity The verbosity of the result. 0 for hex encoded data, 1 for a json object, and 2 for json object with transaction data
8 | */
9 | api.native.get_block = (
10 | coin,
11 | hashorheight,
12 | verbosity = 1,
13 | ) => {
14 | return new Promise((resolve, reject) => {
15 | api.native
16 | .callDaemon(
17 | coin,
18 | "getblock",
19 | [
20 | hashorheight,
21 | verbosity
22 | ]
23 | )
24 | .then(resultObj => {
25 | resolve(resultObj)
26 | })
27 | .catch(err => {
28 | reject(err);
29 | });
30 | });
31 | };
32 |
33 | api.setPost('/native/get_block', (req, res, next) => {
34 | const {
35 | chainTicker,
36 | hashorheight,
37 | verbosity
38 | } = req.body;
39 |
40 | api.native
41 | .get_block(
42 | chainTicker,
43 | hashorheight,
44 | verbosity
45 | )
46 | .then(resultObj => {
47 | const retObj = {
48 | msg: "success",
49 | result: resultObj
50 | };
51 |
52 | res.send(JSON.stringify(retObj));
53 | })
54 | .catch(error => {
55 | const retObj = {
56 | msg: "error",
57 | result: error.message
58 | };
59 |
60 | res.send(JSON.stringify(retObj));
61 | });
62 | });
63 |
64 | return api;
65 | }
--------------------------------------------------------------------------------
/routes/api/native/getVdxfId.js:
--------------------------------------------------------------------------------
1 | module.exports = (api) => {
2 | /**
3 | * Returns the VDXF key of the URI string.
4 | *
5 | * @param {String} coin The chainTicker of the coin to make the call on
6 | * @param {String} vdxfuri This message is converted from hex, the data is hashed, then returned
7 | * @param {Object} initialvdxfdata The optional data of (vdxfkey, uint256, indexnum) that is combined.
8 | */
9 | api.native.get_vdxf_id = (
10 | coin,
11 | vdxfuri,
12 | initialvdxfdata = {},
13 | ) => {
14 | return new Promise((resolve, reject) => {
15 | api.native
16 | .callDaemon(
17 | coin,
18 | "getvdxfid",
19 | [
20 | vdxfuri,
21 | initialvdxfdata
22 | ]
23 | )
24 | .then(resultObj => {
25 | resolve(resultObj)
26 | })
27 | .catch(err => {
28 | reject(err);
29 | });
30 | });
31 | };
32 |
33 | api.setPost('/native/get_vdxf_id', (req, res, next) => {
34 | const {
35 | chainTicker,
36 | vdxfuri,
37 | initialvdxfdata
38 | } = req.body;
39 |
40 | api.native
41 | .get_vdxf_id(
42 | chainTicker,
43 | vdxfuri,
44 | initialvdxfdata
45 | )
46 | .then(resultObj => {
47 | const retObj = {
48 | msg: "success",
49 | result: resultObj
50 | };
51 |
52 | res.send(JSON.stringify(retObj));
53 | })
54 | .catch(error => {
55 | const retObj = {
56 | msg: "error",
57 | result: error.message
58 | };
59 |
60 | res.send(JSON.stringify(retObj));
61 | });
62 | });
63 |
64 | return api;
65 | }
--------------------------------------------------------------------------------
/routes/api/utils/request/request.js:
--------------------------------------------------------------------------------
1 | const axios = require('axios')
2 |
3 | function parseError(error) {
4 | return error.response ? error.response.data.message : error.toString()
5 | }
6 |
7 | async function formatResponse(call, returnFull) {
8 | try {
9 | const res = await call();
10 | return returnFull ? res : res.data;
11 | } catch (error) {
12 | throw new Error(parseError(error));
13 | }
14 | };
15 |
16 | function requestContentType(contentType, method, url, body = {}, options = {}, returnFull = false) {
17 | return formatResponse(() => {
18 | switch (method) {
19 | case "GET":
20 | return axios.get(url, {
21 | ...options,
22 | headers:
23 | options.headers != null
24 | ? { ...options.headers, "Content-Type": contentType }
25 | : { "Content-Type": contentType },
26 | });
27 | case "POST":
28 | return axios.post(url, body, {
29 | ...options,
30 | headers:
31 | options.headers != null
32 | ? { ...options.headers, "Content-Type": contentType }
33 | : { "Content-Type": contentType },
34 | });
35 | default:
36 | throw new Error(method + " is not a valid method type.");
37 | }
38 | }, returnFull);
39 | }
40 |
41 | function requestJson(method, url, body = {}, options = {}, returnFull = false) {
42 | return requestContentType("application/json", method, url, body, options, returnFull)
43 | }
44 |
45 | function requestXml(method, url, body = {}, options = {}, returnFull = false) {
46 | return requestContentType("application/xml", method, url, body, options, returnFull)
47 | }
48 |
49 | module.exports = {
50 | requestJson,
51 | requestXml
52 | }
--------------------------------------------------------------------------------
/routes/api/utils/standardization/standardizeInfo.js:
--------------------------------------------------------------------------------
1 | const { requestJson } = require('../request/request');
2 |
3 | const standardizeZecInfo = (info) => {
4 | return new Promise(async (resolve, reject) => {
5 | try {
6 | const res = await requestJson(
7 | "GET",
8 | "https://api.zcha.in/v2/mainnet/network"
9 | );
10 |
11 | resolve({...info, longestchain: res.blockNumber})
12 | } catch(e) {
13 | reject(e)
14 | }
15 | })
16 | }
17 |
18 | const standardizationFns = {
19 | ['ZEC']: standardizeZecInfo
20 | }
21 |
22 | /**
23 | * Standardizes the behaviour of the get_info call to always include
24 | * utilized important values like 'longestchain' when they may not be
25 | * present, e.g., in ZEC. Returns a promise resolving to the standardized
26 | * info object.
27 | *
28 | * @param {Object} info The info result object to standardize
29 | * @param {String} coin The coin ticker to standardize
30 | * @param {Object} api The api object (for logging purposes)
31 | */
32 | const standardizeInfo = (info, coin, api) => {
33 | let standardizationPromises = []
34 |
35 | if (standardizationFns[coin] != null) {
36 | standardizationPromises.push(
37 | standardizationFns[coin](info)
38 | );
39 | } else {
40 | standardizationPromises = [info]
41 | }
42 |
43 | return new Promise((resolve, reject) => {
44 | Promise.all(standardizationPromises)
45 | .then(infoArr => resolve(infoArr[0]))
46 | .catch(e => {
47 | api.log(`info standardization failed for ${coin}, returning regular info object:`, 'standardizeInfo');
48 | api.log(e, 'standardizeInfo')
49 | resolve(info);
50 | });
51 | });
52 | }
53 |
54 | module.exports = standardizeInfo
--------------------------------------------------------------------------------
/routes/api/native/verusid/provision/verifyIdProvisioningResponse.js:
--------------------------------------------------------------------------------
1 | const { LoginConsentProvisioningResponse } = require("verus-typescript-primitives");
2 | const { ROOT_SYSTEM_NAME } = require("../../../utils/constants/dev_options");
3 |
4 | module.exports = (api) => {
5 | /**
6 | * Verifies a provisioning response
7 | * @param {LoginConsentProvisioningResponse} Response
8 | */
9 | api.native.verusid.provision.verify_id_provisioning_response = async (response) => {
10 | const provisioningResponse = new LoginConsentProvisioningResponse(response);
11 |
12 | // Convert the system id to the chain name.
13 | const currencyObject = await api.native.get_currency(
14 | ROOT_SYSTEM_NAME,
15 | response.system_id
16 | );
17 | const chainTicker = currencyObject.name.toUpperCase();
18 |
19 | const verified = await api.native.verify_hash(
20 | chainTicker,
21 | provisioningResponse.signing_id,
22 | provisioningResponse.decision.toSha256().toString('hex'),
23 | provisioningResponse.signature.signature
24 | );
25 |
26 | return verified ? { verified } : { verified, message: "Failed to verify signature" };
27 | };
28 |
29 | api.setPost("/native/verusid/provision/verify_id_provisioning_response", async (req, res, next) => {
30 | const { response } = req.body;
31 |
32 | try {
33 | res.send(
34 | JSON.stringify({
35 | msg: "success",
36 | result: await api.native.verusid.provision.verify_id_provisioning_response(response),
37 | })
38 | );
39 | } catch (e) {
40 | res.send(
41 | JSON.stringify({
42 | msg: "error",
43 | result: e.message,
44 | })
45 | );
46 | }
47 | });
48 |
49 | return api;
50 | };
51 |
--------------------------------------------------------------------------------
/routes/preloads/plugin/preload-default.js:
--------------------------------------------------------------------------------
1 | /*
2 | Reasonably Secure Electron
3 | Copyright (C) 2019 Bishop Fox
4 | This program is free software; you can redistribute it and/or
5 | modify it under the terms of the GNU General Public License
6 | as published by the Free Software Foundation; either version 2
7 | of the License, or (at your option) any later version.
8 | This program is distributed in the hope that it will be useful,
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 | GNU General Public License for more details.
12 | You should have received a copy of the GNU General Public License
13 | along with this program; if not, write to the Free Software
14 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 | -------------------------------------------------------------------------
16 | This preload script is callable from within the sandbox via postMessage,
17 | but should not be directly accessible since it itself is not sandboxed.
18 | */
19 |
20 | const { ipcRenderer } = require('electron');
21 |
22 |
23 | window.addEventListener('message', (event) => {
24 | try {
25 | const msg = JSON.parse(event.data);
26 | if (msg.type === 'request') {
27 | if (['fs_'].some(prefix => msg.method.startsWith(prefix))) {
28 | ipcRenderer.send('ipc', msg);
29 | }
30 | }
31 | } catch (err) {
32 | console.error(err);
33 | }
34 | });
35 |
36 | ipcRenderer.on('ipc', (_, msg) => {
37 | try {
38 | if (msg.type === 'response' || msg.type === 'push' || msg.type === 'init') {
39 | console.log(JSON.parse(msg.data))
40 |
41 | window.postMessage(JSON.stringify(msg), '*');
42 | }
43 | } catch (err) {
44 | console.error(err);
45 | }
46 | });
--------------------------------------------------------------------------------
/routes/api/plugin/builtin/pbaasvisualizer.js:
--------------------------------------------------------------------------------
1 | const { pushMessage } = require('../../../ipc/ipc');
2 | const { ReservedPluginTypes } = require('../../utils/plugin/builtin');
3 |
4 | module.exports = (api) => {
5 | api.pbaasVisualizer = {}
6 |
7 | api.pbaasVisualizer.visualize = async (
8 | request,
9 | originInfo
10 | ) => {
11 | return new Promise((resolve, reject) => {
12 | try {
13 | api.startPlugin(
14 | ReservedPluginTypes.VERUS_PBAAS_VISUALIZER,
15 | true,
16 | () => {},
17 | (pluginWindow) => {
18 | pushMessage(
19 | pluginWindow,
20 | {
21 | request: request,
22 | origin_app_info: originInfo,
23 | },
24 | "VERUS_PBAAS_VISUALIZER_REQUEST"
25 | );
26 | },
27 | 1280,
28 | 850
29 | );
30 |
31 | // No need to wait for any data to be returned, visualization is static
32 | resolve()
33 | } catch (e) {
34 | reject(e);
35 | }
36 | });
37 | };
38 |
39 | api.setPost('/plugin/builtin/verus_pbaas_visualizer/visualize', async (req, res, next) => {
40 | const { request } = req.body;
41 | const { app_id, builtin } = req.api_header
42 |
43 | try {
44 | const retObj = {
45 | msg: "success",
46 | result: await api.pbaasVisualizer.visualize(
47 | request,
48 | {
49 | id: app_id,
50 | search_builtin: builtin,
51 | }
52 | ),
53 | };
54 |
55 | res.send(JSON.stringify(retObj));
56 | } catch (e) {
57 | const retObj = {
58 | msg: 'error',
59 | result: e.message,
60 | };
61 |
62 | res.send(JSON.stringify(retObj));
63 | }
64 | });
65 |
66 | return api;
67 | };
--------------------------------------------------------------------------------
/routes/api/erc20/addresses.js:
--------------------------------------------------------------------------------
1 | const { ethers } = require("ethers");
2 |
3 | module.exports = (api) => {
4 | api.erc20.get_address = () => {
5 | if (api.erc20.wallet != null) {
6 | return api.erc20.wallet.address
7 | } else {
8 | throw new Error("No wallet authenticated, cannot get wallet address for ERC20")
9 | }
10 | };
11 |
12 | api.erc20.get_addresses = async (contractId) => {
13 | return {
14 | public: [
15 | {
16 | address: api.erc20.get_address(),
17 | tag: "eth",
18 | balances: {
19 | native: ethers.formatUnits(
20 | await api.erc20.get_wallet_balance(contractId),
21 | api.erc20.contracts[contractId].decimals
22 | ),
23 | reserve: {},
24 | },
25 | },
26 | ],
27 | private: [],
28 | };
29 | };
30 |
31 | api.setGet('/erc20/get_addresses', (req, res, next) => {
32 | api.erc20.get_addresses(req.query.chainTicker)
33 | .then((addresses) => {
34 | const retObj = {
35 | msg: 'success',
36 | result: addresses,
37 | };
38 |
39 | res.send(JSON.stringify(retObj));
40 | })
41 | .catch(error => {
42 | const retObj = {
43 | msg: 'error',
44 | result: error.message,
45 | };
46 |
47 | res.send(JSON.stringify(retObj));
48 | })
49 | });
50 |
51 | api.setPost('/erc20/get_privkey', (req, res, next) => {
52 | if (api.erc20.wallet != null) {
53 | res.send(JSON.stringify({
54 | msg: 'success',
55 | result: api.erc20.wallet.signer.signingKey.privateKey,
56 | }));
57 | } else {
58 | res.send(JSON.stringify({
59 | msg: 'error',
60 | result: `No ETH privkey found`
61 | }));
62 | }
63 | }, true);
64 |
65 | return api;
66 | };
--------------------------------------------------------------------------------
/routes/api/native/estimateSendcurrencyFee.js:
--------------------------------------------------------------------------------
1 | module.exports = (api) => {
2 | api.native.estimate_sendcurrency_fee = async (chain, _params, minconfs = 1, sendfee = 0.0001) => {
3 | try {
4 | let feecurrency;
5 |
6 | const vETH = await api.native.get_currency(chain, 'vETH');
7 |
8 | // These are throwaway addresses, without any funds, to ensure this
9 | // tx would fail if it were to be broadcasted, or at least not spend
10 | // any user funds in the absolute worst case scenario.
11 | const raddr = "RGM3raQ1McqQYZpFyuBrqUpLnmgK7h8k4A"
12 | const address = _params.exportto === vETH.currencyid ?
13 | "0xd62971620094e8244F1ed3B12a8D31bC969081fA"
14 | :
15 | raddr;
16 |
17 | const params = {..._params, amount: 0, address};
18 |
19 | const res = await api.native.callDaemon(chain, 'sendcurrency', [raddr, [params], minconfs, sendfee, true]);
20 |
21 | if (params.feecurrency == null) {
22 | const chainCurrency = await api.native.get_currency(chain, chain);
23 | feecurrency = chainCurrency.currencyid;
24 | } else feecurrency = params.feecurrency;
25 |
26 | return res.outputtotals[feecurrency];
27 | } catch(e) {
28 | throw e
29 | }
30 | };
31 |
32 | api.setPost('/native/estimate_sendcurrency_fee', async (req, res, next) => {
33 | const { chainTicker, params, minconfs, sendfee } = req.body;
34 |
35 | try {
36 | const retObj = {
37 | msg: 'success',
38 | result: await api.native.estimate_sendcurrency_fee(chainTicker, params, minconfs, sendfee),
39 | };
40 |
41 | res.send(JSON.stringify(retObj));
42 | } catch(e) {
43 | const retObj = {
44 | msg: 'error',
45 | result: e.message,
46 | };
47 |
48 | res.send(JSON.stringify(retObj));
49 | }
50 | });
51 |
52 | return api;
53 | };
--------------------------------------------------------------------------------
/routes/api/downloadUtil.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs-extra');
2 | const http = require('http')
3 | const https = require('https')
4 | const axios = require('axios')
5 |
6 | module.exports = (api) => {
7 | /**
8 | * Promise based download file method
9 | */
10 | api.downloadFile = (configuration) => {
11 | return new Promise(async (resolve, reject) => {
12 | try {
13 | // Save variable to know progress
14 | let receivedBytes = 0;
15 | let totalBytes = 0;
16 | const httpAgent = new http.Agent({ keepAlive: true });
17 | const httpsAgent = new https.Agent({ keepAlive: true });
18 |
19 | const req = await axios({
20 | method: 'get',
21 | url: configuration.remoteFile,
22 | responseType: 'stream',
23 | httpAgent,
24 | httpsAgent,
25 | })
26 |
27 | let out = fs.createWriteStream(configuration.localFile);
28 | req.data.pipe(out);
29 |
30 | req.data.on("response", (data) => {
31 | // Change the total bytes value to get progress later.
32 | totalBytes = parseInt(data.headers["content-length"]);
33 | });
34 |
35 | // Get progress if callback exists
36 | if (configuration.hasOwnProperty("onProgress")) {
37 | req.data.on("data", (chunk) => {
38 | // Update the received bytes
39 | receivedBytes += chunk.length;
40 | configuration.onProgress(receivedBytes, totalBytes);
41 | });
42 | } else {
43 | req.data.on("data", (chunk) => {
44 | // Update the received bytes
45 | receivedBytes += chunk.length;
46 | });
47 | }
48 |
49 | req.data.on("end", () => {
50 | resolve();
51 | });
52 | } catch (e) {
53 | reject(e);
54 | }
55 |
56 | });
57 | }
58 |
59 | return api;
60 | };
--------------------------------------------------------------------------------
/routes/api/native/verusid/provision/signIdProvisioningRequest.js:
--------------------------------------------------------------------------------
1 | const { VerusIDSignature, IDENTITY_AUTH_SIG_VDXF_KEY } = require("verus-typescript-primitives");
2 | const { ProvisioningRequest } = require("verus-typescript-primitives/dist/vdxf/classes/provisioning/ProvisioningRequest");
3 |
4 | module.exports = (api) => {
5 | /**
6 | * Signs a provisioning request using an r-address.
7 | *
8 | * @param {String} coin The chainTicker of the coin to make the call on
9 | * @param {String} request The provisioning request to sign
10 | * @param {String} raddress The raddress to sign the provioning requset with
11 | */
12 | api.native.verusid.provision.sign_id_provisioning_request = async (coin, request, raddress) => {
13 |
14 | const provisioningRequest = new ProvisioningRequest(request);
15 |
16 | const signdataResult = await api.native.sign_data(coin,
17 | {
18 | "address": raddress,
19 | "datahash": provisioningRequest.challenge.toSha256().toString("hex")
20 | }
21 | )
22 |
23 | provisioningRequest.signature = new VerusIDSignature(
24 | { signature: signdataResult.signature },
25 | IDENTITY_AUTH_SIG_VDXF_KEY
26 | );
27 |
28 | return provisioningRequest;
29 | }
30 |
31 | api.setPost('/native/verusid/provision/sign_id_provisioning_request', async (req, res, next) => {
32 | const {
33 | chainTicker,
34 | request,
35 | raddress
36 | } = req.body;
37 |
38 | try {
39 | res.send(
40 | JSON.stringify({
41 | msg: "success",
42 | result: await api.native.verusid.provision.sign_id_provisioning_request(chainTicker, request, raddress),
43 | })
44 | );
45 | } catch (e) {
46 | res.send(
47 | JSON.stringify({
48 | msg: "error",
49 | result: e.message,
50 | })
51 | );
52 | }
53 | });
54 |
55 | return api;
56 | }
--------------------------------------------------------------------------------
/routes/api/electrum/block.js:
--------------------------------------------------------------------------------
1 |
2 | module.exports = (api) => {
3 | api.setGet('/electrum/getblockinfo', (req, res, next) => {
4 | api.electrumGetBlockInfo(req.query.height, req.query.network)
5 | .then((json) => {
6 | const retObj = {
7 | msg: 'success',
8 | result: json,
9 | };
10 |
11 | res.send(JSON.stringify(retObj));
12 | });
13 | });
14 |
15 | api.electrumGetBlockInfo = (height, network) => {
16 | return new Promise((resolve, reject) => {
17 | async function _electrumGetBlockInfo() {
18 | const ecl = await api.ecl(network);
19 |
20 | ecl.blockchainBlockGetHeader(height).then((json) => {
21 | api.log("electrum getblockinfo ==>", "spv.getblockinfo");
22 | api.log(json, "spv.getblockinfo");
23 |
24 | resolve(json);
25 | });
26 | }
27 | _electrumGetBlockInfo();
28 | });
29 | }
30 |
31 | api.setGet('/electrum/getcurrentblock', (req, res, next) => {
32 | api.electrumGetCurrentBlock(req.query.network)
33 | .then((json) => {
34 | const retObj = {
35 | msg: 'success',
36 | result: json,
37 | };
38 |
39 | res.send(JSON.stringify(retObj));
40 | });
41 | });
42 |
43 | api.electrumGetCurrentBlock = (network, returnNspvReq) => {
44 | return new Promise((resolve, reject) => {
45 | async function _electrumGetCurrentBlock() {
46 | const ecl = await api.ecl(network);
47 |
48 | ecl.blockchainHeadersSubscribe().then((json) => {
49 | if (json && json.hasOwnProperty("block_height")) {
50 | resolve(json.block_height);
51 | } else if (json && json.hasOwnProperty("height")) {
52 | resolve(json.height);
53 | } else {
54 | resolve(json);
55 | }
56 | });
57 | };
58 | _electrumGetCurrentBlock();
59 | });
60 | }
61 |
62 | return api;
63 | };
--------------------------------------------------------------------------------
/routes/api/system.js:
--------------------------------------------------------------------------------
1 | const si = require('systeminformation')
2 |
3 | module.exports = (api) => {
4 | /*
5 | * type: GET
6 | */
7 | api.setGet('/get_static_system_data', (req, res, next) => {
8 | si.getStaticData()
9 | .then(data => {
10 | res.send(JSON.stringify({
11 | msg: 'success',
12 | result: data
13 | }));
14 | })
15 | .catch(e => {
16 | res.send(JSON.stringify({
17 | msg: 'error',
18 | result: e.message
19 | }));
20 | })
21 | });
22 |
23 | /*
24 | * type: GET
25 | */
26 | api.setGet('/get_cpu_temp', (req, res, next) => {
27 | const CPU_TEMP_UNSUPPORTED = null
28 |
29 | si.cpuTemperature()
30 | .then(data => {
31 | if (data.main && data.main === CPU_TEMP_UNSUPPORTED) throw new Error('unsupported_operation')
32 |
33 | res.send(JSON.stringify({
34 | msg: 'success',
35 | result: data
36 | }));
37 | })
38 | .catch(e => {
39 | res.send(JSON.stringify({
40 | msg: 'error',
41 | result: e.message
42 | }));
43 | })
44 | });
45 |
46 | /*
47 | * type: GET
48 | */
49 | api.setGet('/get_cpu_load', (req, res, next) => {
50 | si.currentLoad()
51 | .then(data => {
52 | res.send(JSON.stringify({
53 | msg: 'success',
54 | result: data
55 | }));
56 | })
57 | .catch(e => {
58 | res.send(JSON.stringify({
59 | msg: 'error',
60 | result: e.message
61 | }));
62 | })
63 | });
64 |
65 | /*
66 | * type: GET
67 | */
68 | api.setGet('/get_sys_time', (req, res, next) => {
69 | try {
70 | res.send(JSON.stringify({
71 | msg: 'success',
72 | result: si.time()
73 | }));
74 | } catch (e) {
75 | res.send(JSON.stringify({
76 | msg: 'error',
77 | result: e.message
78 | }));
79 | }
80 | });
81 |
82 | return api;
83 | };
84 |
--------------------------------------------------------------------------------
/test/verusid-login.js:
--------------------------------------------------------------------------------
1 | const test_request = {
2 | chain_id: "VRSCTEST",
3 | signing_id: "login-consent-server@",
4 | signature: {
5 | signature:
6 | "AaYuAAABQSD/UR9NIeimLYyUrkJ7kfjXJz0QiuVsFIt+lEu+KSELCX5zxAlIiciuIHLIzKLsuqMFL3XDapg/1TnV0b6hXoSX",
7 | },
8 | challenge: {
9 | uuid: "7bb518c4eec2454dbb289f5fdb4c0ee2",
10 | requested_scope: ["vrsc::system.identity.authentication.scope.read-id-name"],
11 | requested_access_token_audience: null,
12 | skip: false,
13 | oidc_context: {},
14 | request_url: "http://127.0.0.1:4444/oauth2?full=request&url=",
15 | client: {
16 | client_id: "auth-code-client",
17 | name: "Online Service",
18 | redirect_uris: ["http://127.0.0.1:5555/callback"],
19 | grant_types: ["authorization_code", "refresh_token"],
20 | response_types: ["code", "id_token"],
21 | scope: "vrsc::system.identity.authentication.scope.read-id-name",
22 | audience: null,
23 | owner: "",
24 | policy_uri: "https://verus.io/privacy-policy",
25 | allowed_cors_origins: null,
26 | tos_uri: "https://en.wikipedia.org/wiki/Lorem_ipsum",
27 | client_uri: "https://verus.io/",
28 | logo_uri:
29 | "https://github.com/VerusCoin/Media-Assets/blob/master/Logos/PNG%20(pixel)/Logo/verus-icon-blue-500px.png",
30 | contacts: null,
31 | client_secret_expires_at: 0,
32 | subject_type: "public",
33 | token_endpoint_auth_method: "client_secret_basic",
34 | userinfo_signed_response_alg: "none",
35 | created_at: "2020-07-08T12:31:47Z",
36 | updated_at: "2020-07-08T12:31:47Z",
37 | },
38 | },
39 | };
40 |
41 | const test_response_no_sig = {
42 | chain_id: "VRSCTEST",
43 | signing_id: "login-consent-server@",
44 | decision: {
45 | subject: "Client@",
46 | remember: true,
47 | remember_for: 7200,
48 | force_subject_identifier: "string",
49 | request: test_request,
50 | },
51 | };
52 |
--------------------------------------------------------------------------------
/routes/api/data_files/backup.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs-extra');
2 |
3 | module.exports = (api) => {
4 | /**
5 | * Backs up all necessary app data stored for Verus Desktop
6 | */
7 | api.backupAppData = async (backupName) => {
8 | if (
9 | backupName.includes(".") ||
10 | backupName.includes("/") ||
11 | backupName.includes("\\") ||
12 | backupName.includes("*") ||
13 | backupName.includes("~") ||
14 | backupName == null
15 | ) {
16 | throw new Error(`Backup data name (${backupName}) cannot include any of the following: ./\\*~`)
17 | }
18 |
19 | try {
20 | await fs.access(api.paths.agamaDir, fs.constants.R_OK);
21 | } catch (e) {
22 | if (e.code == "EACCES") {
23 | await fs.chmod(path, "0666");
24 | } else if (e.code === "ENOENT") {
25 | api.handleFileProblem(`Verus Desktop directory not found`, !handleErrors)
26 | return
27 | }
28 | }
29 |
30 | try {
31 | const backupPath = `${api.paths.backupDir}/${backupName}`
32 |
33 | if (await fs.exists(backupPath)) {
34 | throw new Error(`Backup at ${backupPath} already exists!`)
35 | }
36 |
37 | await fs.copy(api.paths.agamaDir, backupPath);
38 |
39 | api.log(
40 | `appdata backup created at ${backupPath}`,
41 | "backup"
42 | );
43 | return
44 | } catch (e) {
45 | api.log(e, 'backup');
46 | throw e
47 | }
48 | };
49 |
50 | api.setPost('/backup_appdata', async (req, res, next) => {
51 | const { dirName } = req.body
52 |
53 | try {
54 | const retObj = {
55 | msg: 'success',
56 | result: await api.backupAppData(dirName),
57 | };
58 |
59 | res.send(JSON.stringify(retObj));
60 | } catch (e) {
61 | const retObj = {
62 | msg: 'error',
63 | result: e.message,
64 | };
65 |
66 | res.send(JSON.stringify(retObj));
67 | }
68 | });
69 |
70 | return api;
71 | };
--------------------------------------------------------------------------------
/test/spec-kmd.js:
--------------------------------------------------------------------------------
1 | const Application = require('spectron').Application
2 | const assert = require('assert')
3 | const electronPath = require('electron') // Require Electron from the binaries included in node_modules.
4 | const path = require('path')
5 | const chai = require('chai')
6 | const timeout = 7500;
7 | describe('Application launch testing native KMD coin', function () {
8 | this.timeout(timeout)
9 | before(function () {
10 | this.gotDomReadyCount = 0
11 | this.app = new Application({
12 | path: electronPath,
13 | // The following line tells spectron to look and use the main.js file
14 | // and the package.json located 1 level above.
15 | args: [path.join(__dirname, '..')],
16 | startTimeout: timeout,
17 | waitTimeout: timeout
18 | })
19 | return this.app.start()
20 | })
21 |
22 | after(function () {
23 | if (this.app && this.app.isRunning()) {
24 | return this.app.stop()
25 | }
26 | })
27 |
28 | it('opens a window', function (done) {
29 | this.app.client.waitUntilWindowLoaded()
30 | .getWindowCount().then(function (count) {
31 | assert.equal(count, 1)
32 | done()
33 | })
34 | })
35 |
36 | it('has a native coin list that takes kmd', function (done) {
37 | // Wait for the left button for native mode coins is visible
38 | this.app.client.element('#react-select-3--value').waitForVisible(3000)
39 | // Click on it and enter kmd
18 |
24 |
29 |
24 |
25 | App is closing. Please wait...
26 | This may take a while depending on your system resources and current state of daemon applications. 27 |
28 | 26 | This may take a while depending on your system resources and current state of daemon applications. 27 |