mirror of
https://github.com/Qortal/qortal-ui.git
synced 2025-04-23 03:17:51 +00:00
481 lines
10 KiB
JavaScript
481 lines
10 KiB
JavaScript
import { store } from '../store.js'
|
|
import {
|
|
doAddPluginUrl,
|
|
doUpdateBlockInfo,
|
|
doUpdateNodeStatus,
|
|
doUpdateNodeInfo,
|
|
doSetNode,
|
|
doPageUrl,
|
|
doSetChatHeads,
|
|
doUpdateAccountInfo,
|
|
} from '../redux/app/app-actions.js'
|
|
import * as api from 'qortal-ui-crypto'
|
|
import { requestTransactionDialog } from '../functional-components/confirm-transaction-dialog.js'
|
|
import { doNewMessage } from '../notifications/controller.js'
|
|
import snackbar from '../functional-components/snackbar.js'
|
|
import {
|
|
loadStateFromLocalStorage,
|
|
saveStateToLocalStorage,
|
|
} from '../localStorageHelpers.js'
|
|
|
|
const createTransaction = api.createTransaction
|
|
const processTransaction = api.processTransaction
|
|
const processTransactionVersion2 = api.processTransactionVersion2
|
|
const signChatTransaction = api.signChatTransaction
|
|
const signArbitraryTransaction = api.signArbitraryTransaction
|
|
const signArbitraryWithFeeTransaction = api.signArbitraryWithFeeTransaction
|
|
const tradeBotCreateRequest = api.tradeBotCreateRequest
|
|
const tradeBotRespondRequest = api.tradeBotRespondRequest
|
|
const signTradeBotTxn = api.signTradeBotTxn
|
|
const deleteTradeOffer = api.deleteTradeOffer
|
|
const cancelAllOffers = api.cancelAllOffers
|
|
const sendBtc = api.sendBtc
|
|
const sendLtc = api.sendLtc
|
|
const sendDoge = api.sendDoge
|
|
const sendDgb = api.sendDgb
|
|
const sendRvn = api.sendRvn
|
|
const sendArrr = api.sendArrr
|
|
|
|
export const routes = {
|
|
registerUrl: async (req) => {
|
|
store.dispatch(doAddPluginUrl(req.data))
|
|
},
|
|
|
|
setAccountInfo: async (req) => {
|
|
store.dispatch(doUpdateAccountInfo(req.data))
|
|
},
|
|
|
|
getAccountInfo: async (req) => {
|
|
return store.getState().app.accountInfo
|
|
},
|
|
|
|
setChatHeads: async (req) => {
|
|
return store.dispatch(doSetChatHeads(req.data))
|
|
},
|
|
|
|
getChatHeads: async (req) => {
|
|
return store.getState().app.chatHeads
|
|
},
|
|
|
|
updateBlockInfo: async (req) => {
|
|
store.dispatch(doUpdateBlockInfo(req.data))
|
|
},
|
|
|
|
updateNodeStatus: async (req) => {
|
|
store.dispatch(doUpdateNodeStatus(req.data))
|
|
},
|
|
|
|
updateNodeInfo: async (req) => {
|
|
store.dispatch(doUpdateNodeInfo(req.data))
|
|
},
|
|
|
|
setNode: async (req) => {
|
|
store.dispatch(doSetNode(req.data))
|
|
},
|
|
|
|
getNodeConfig: async (req) => {
|
|
return store.getState().app.nodeConfig
|
|
},
|
|
|
|
setPageUrl: async (req) => {
|
|
return store.dispatch(doPageUrl(req.data))
|
|
},
|
|
|
|
getLocalStorage: async (req) => {
|
|
return loadStateFromLocalStorage(req.data)
|
|
},
|
|
|
|
setLocalStorage: async (req) => {
|
|
return saveStateToLocalStorage(req.data.key, req.data.dataObj)
|
|
},
|
|
|
|
apiCall: async (req) => {
|
|
const url = req.data.url
|
|
delete req.data.url
|
|
return api.request(url, req.data)
|
|
},
|
|
|
|
addresses: async (req) => {
|
|
return store.getState().app.wallet.addresses.map((address) => {
|
|
return {
|
|
address: address.address,
|
|
color: address.color,
|
|
nonce: address.nonce,
|
|
textColor: address.textColor,
|
|
base58PublicKey: address.base58PublicKey,
|
|
}
|
|
})
|
|
},
|
|
|
|
transaction: async (req) => {
|
|
let response
|
|
try {
|
|
const tx = createTransaction(
|
|
req.data.type,
|
|
store.getState().app.wallet._addresses[req.data.nonce].keyPair,
|
|
req.data.params
|
|
)
|
|
|
|
if (!req.disableModal && !req.data.disableModal) {
|
|
await requestTransactionDialog.requestTransaction(tx)
|
|
}
|
|
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(tx.signedBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(tx.signedBytes)
|
|
}
|
|
|
|
let extraData = {}
|
|
if(req.data.type === 38 && tx && tx._rewardShareKeyPair && tx._rewardShareKeyPair.secretKey){
|
|
extraData.rewardSharePrivateKey = Base58.encode(tx._rewardShareKeyPair.secretKey)
|
|
}
|
|
|
|
|
|
response = {
|
|
success: true,
|
|
data: res,
|
|
extraData
|
|
}
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = {
|
|
success: false,
|
|
message: e.message,
|
|
}
|
|
}
|
|
return response
|
|
},
|
|
|
|
standaloneTransaction: async (req) => {
|
|
const rebuildUint8Array = (obj) => {
|
|
let _array = new Uint8Array(Object.keys(obj).length)
|
|
for (let i = 0; i < _array.byteLength; ++i) {
|
|
_array.set([obj[i]], i)
|
|
}
|
|
return _array
|
|
}
|
|
|
|
let response
|
|
try {
|
|
// req.data.keyPair unfortunately "prepared" into horrible object so we need to convert back
|
|
let _keyPair = {}
|
|
for (let _keyName in req.data.keyPair) {
|
|
_keyPair[_keyName] = rebuildUint8Array(
|
|
req.data.keyPair[_keyName]
|
|
)
|
|
}
|
|
const tx = createTransaction(
|
|
req.data.type,
|
|
_keyPair,
|
|
req.data.params
|
|
)
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(tx.signedBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(tx.signedBytes)
|
|
}
|
|
|
|
|
|
response = {
|
|
success: true,
|
|
data: res,
|
|
}
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = {
|
|
success: false,
|
|
message: e.message,
|
|
}
|
|
}
|
|
return response
|
|
},
|
|
|
|
username: async (req) => {
|
|
const state = store.getState()
|
|
const username =
|
|
state.user.storedWallets[state.app.wallet.addresses[0].address]
|
|
.name
|
|
|
|
return username
|
|
},
|
|
|
|
chat: async (req) => {
|
|
let response
|
|
try {
|
|
const tx = createTransaction(
|
|
req.data.type,
|
|
store.getState().app.wallet._addresses[req.data.nonce].keyPair,
|
|
req.data.params
|
|
)
|
|
|
|
response = tx.chatBytes
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = false
|
|
}
|
|
return response
|
|
},
|
|
|
|
sign_chat: async (req) => {
|
|
let response
|
|
try {
|
|
const signedChatBytes = await signChatTransaction(
|
|
req.data.chatBytesArray,
|
|
req.data.chatNonce,
|
|
store.getState().app.wallet._addresses[req.data.nonce].keyPair
|
|
)
|
|
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(signedChatBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(signedChatBytes)
|
|
}
|
|
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = false
|
|
}
|
|
return response
|
|
},
|
|
|
|
sign_arbitrary: async (req) => {
|
|
let response
|
|
try {
|
|
const signedArbitraryBytes = await signArbitraryTransaction(
|
|
req.data.arbitraryBytesBase58,
|
|
req.data.arbitraryBytesForSigningBase58,
|
|
req.data.arbitraryNonce,
|
|
store.getState().app.wallet._addresses[req.data.nonce].keyPair
|
|
)
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(signedArbitraryBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(signedArbitraryBytes)
|
|
}
|
|
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = false
|
|
}
|
|
return response
|
|
},
|
|
|
|
sign_arbitrary_with_fee: async (req) => {
|
|
let response
|
|
try {
|
|
const signedArbitraryBytes = await signArbitraryWithFeeTransaction(
|
|
req.data.arbitraryBytesBase58,
|
|
req.data.arbitraryBytesForSigningBase58,
|
|
store.getState().app.wallet._addresses[req.data.nonce].keyPair
|
|
)
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(signedArbitraryBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(signedArbitraryBytes)
|
|
}
|
|
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = false
|
|
}
|
|
return response
|
|
},
|
|
|
|
showNotification: async (req) => {
|
|
doNewMessage(req.data)
|
|
},
|
|
|
|
showSnackBar: async (req) => {
|
|
snackbar.add({
|
|
labelText: req.data,
|
|
dismiss: true,
|
|
})
|
|
},
|
|
|
|
tradeBotCreateRequest: async (req) => {
|
|
let response
|
|
try {
|
|
const unsignedTxn = await tradeBotCreateRequest(req.data)
|
|
|
|
const signedTxnBytes = await signTradeBotTxn(
|
|
unsignedTxn,
|
|
store.getState().app.selectedAddress.keyPair
|
|
)
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(signedTxnBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(signedTxnBytes)
|
|
}
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
tradeBotRespondRequest: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await tradeBotRespondRequest(req.data)
|
|
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
deleteTradeOffer: async (req) => {
|
|
let response
|
|
try {
|
|
const unsignedTxn = await deleteTradeOffer(req.data)
|
|
|
|
const signedTxnBytes = await signTradeBotTxn(
|
|
unsignedTxn,
|
|
store.getState().app.selectedAddress.keyPair
|
|
)
|
|
|
|
let res
|
|
|
|
if(req.data.apiVersion && req.data.apiVersion === 2){
|
|
res = await processTransactionVersion2(signedTxnBytes)
|
|
}
|
|
if(!req.data.apiVersion){
|
|
res = await processTransaction(signedTxnBytes)
|
|
}
|
|
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
cancelAllOffers: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await cancelAllOffers(
|
|
store.getState().app.selectedAddress
|
|
)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendBtc: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendBtc(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendLtc: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendLtc(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendDoge: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendDoge(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendDgb: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendDgb(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendRvn: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendRvn(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
|
|
sendArrr: async (req) => {
|
|
let response
|
|
try {
|
|
const res = await sendArrr(req.data)
|
|
response = res
|
|
} catch (e) {
|
|
console.error(e)
|
|
console.error(e.message)
|
|
response = e.message
|
|
}
|
|
return response
|
|
},
|
|
}
|