336 lines
8.8 KiB
JavaScript
336 lines
8.8 KiB
JavaScript
import {reaction, makeAutoObservable, onBecomeObserved, onBecomeUnobserved} from "mobx";
|
|
import {cryptography} from "@liskhq/lisk-client";
|
|
import { passphrase, transactions } from "@liskhq/lisk-client";
|
|
import {getNodeInfo} from '../api/node';
|
|
import {fetchWrapper} from '../shared/fetchWrapper';
|
|
import {labelMap} from "../shared/labelMap";
|
|
import {statusMap} from "../shared/statusMap";
|
|
import {generateSvgAvatar} from "../images/GenerateOnboardingSvg/GenerateSvg";
|
|
import {
|
|
encryptAccountData,
|
|
generateSetTransaction, generateTransaction,
|
|
hashAccountData,
|
|
} from '../utils/Utils';
|
|
import {
|
|
removeFeatureAssetSchema,
|
|
setFeatureAssetSchema,
|
|
} from '../utils/Schemas';
|
|
|
|
class Store {
|
|
_accountData = []
|
|
|
|
_passPhrase = ''
|
|
|
|
_nodeInfo = {}
|
|
|
|
_keysArray = []
|
|
|
|
_sharedData = []
|
|
|
|
_transactionsInfo = []
|
|
|
|
_accountInfo = {};
|
|
|
|
_loading = false;
|
|
|
|
constructor() {
|
|
makeAutoObservable(this, {});
|
|
|
|
reaction(() => this.keysArray, () => this.fetchSharedData())
|
|
reaction(() => this.address, () => this.fetchAccountInfo())
|
|
onBecomeObserved(this, "decryptedAccountData", () => this.fetchNewAccountData())
|
|
onBecomeObserved(this, "sharedData", () => this.fetchKeysArray())
|
|
onBecomeUnobserved(this, "sharedData", () => this.unobservedSharedData())
|
|
onBecomeObserved(this, "transactionsInfo", () => this.fetchTransactionsInfo())
|
|
onBecomeUnobserved(this, "transactionsInfo", () => this.unobservedTransactionsInfo())
|
|
|
|
this.fetchNodeInfo()
|
|
};
|
|
|
|
fetchNewAccountData() {
|
|
getNodeInfo()
|
|
.then((info)=>{
|
|
this.fetchNodeInfoSuccess(info)
|
|
fetchWrapper.getAuth('data/private', {
|
|
networkIdentifier: this.nodeInfo.networkIdentifier,
|
|
lastBlockID: this.nodeInfo.lastBlockID
|
|
}).then((res) => this.accountDataFetchChange(res))
|
|
})
|
|
.catch((err) => this.fetchNodeInfoFailed(err))
|
|
}
|
|
|
|
fetchAccountInfo() {
|
|
fetchWrapper.get(`accounts/${this.address}`).then((res) => this.fetchAccountInfoSuccess(res))
|
|
}
|
|
|
|
fetchKeysArray() {
|
|
getNodeInfo()
|
|
.then((info)=>{
|
|
this.fetchNodeInfoSuccess(info)
|
|
fetchWrapper.getAuth('data/shared/', {
|
|
networkIdentifier: this.nodeInfo.networkIdentifier,
|
|
lastBlockID: this.nodeInfo.lastBlockID
|
|
}).then((res) => this.keysArrayFetchChange(res))
|
|
})
|
|
.catch((err) => this.fetchNodeInfoFailed(err))
|
|
}
|
|
|
|
fetchTransactionsInfo() {
|
|
fetchWrapper.get(`account/transactions/${this.address}`, {
|
|
networkIdentifier: this.nodeInfo.networkIdentifier,
|
|
lastBlockID: this.nodeInfo.lastBlockID
|
|
}).then((res) => this.saveInfoTransactions(res))
|
|
};
|
|
|
|
fetchPassPhrase() {
|
|
this._passPhrase = sessionStorage.getItem('passPhrase') || ''
|
|
}
|
|
|
|
fetchSharedData() {
|
|
this._keysArray.forEach((elem) => fetchWrapper.get(`data/shared/${elem}`).then((res) => this.changeSharedData(res)))
|
|
};
|
|
|
|
fetchNodeInfo() {
|
|
getNodeInfo()
|
|
.then((info)=>this.fetchNodeInfoSuccess(info))
|
|
.catch((err) => this.fetchNodeInfoFailed(err))
|
|
}
|
|
|
|
pushAccountData(data = this.accountData) {
|
|
fetchWrapper.postAuth('data/private', {
|
|
networkIdentifier: this.nodeInfo.networkIdentifier,
|
|
lastBlockID: this.nodeInfo.lastBlockID
|
|
}, [...encryptAccountData(data, this.passPhrase, this.pubKey)])
|
|
.then(() => this.fetchNewAccountData())
|
|
}
|
|
|
|
pushAccountDataToBlockchain(data = this.decryptedAccountData) {
|
|
const [removed, changed] = hashAccountData(data, this.decryptedAccountData, this.accountFeaturesMap)
|
|
const builder = generateTransaction(BigInt(this.accountInfo?.sequence?.nonce || 0), this.addressAndPubKey.publicKey, this.nodeInfo.networkIdentifier, this.passPhrase);
|
|
|
|
let signedTx = null;
|
|
|
|
if(removed.length !== 0)
|
|
signedTx = builder.remove(removed);
|
|
|
|
if(changed.length !== 0)
|
|
signedTx = builder.update(changed)
|
|
if(signedTx) {
|
|
fetchWrapper.post('transactions', {}, signedTx);
|
|
this.accountInfo.sequence.nonce++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
generatePassPhrase() {
|
|
this._passPhrase = passphrase.Mnemonic.generateMnemonic();
|
|
sessionStorage.setItem('passPhrase', this._passPhrase);
|
|
};
|
|
|
|
savePastPassPhrase(phrase) {
|
|
this._passPhrase=phrase
|
|
sessionStorage.setItem('passPhrase', this._passPhrase);
|
|
};
|
|
|
|
unobservedTransactionsInfo() {
|
|
this._transactionsInfo = []
|
|
};
|
|
|
|
unobservedSharedData() {
|
|
this._sharedData = []
|
|
};
|
|
|
|
changeSharedData(incomingData) {
|
|
this._sharedData.push({
|
|
data: incomingData.data,
|
|
})
|
|
}
|
|
|
|
saveDataRegistration(data) {
|
|
this._accountData = data;
|
|
};
|
|
|
|
clearDataRegistration() {
|
|
this._accountData = [];
|
|
};
|
|
|
|
saveInfoTransactions(transaction) {
|
|
this._transactionsInfo = transaction.data
|
|
}
|
|
|
|
accountDataFetchChange(res) {
|
|
if (res.data) {
|
|
this._accountData = res.data;
|
|
}
|
|
};
|
|
|
|
keysArrayFetchChange(res) {
|
|
this._keysArray = res.data;
|
|
}
|
|
|
|
fetchNodeInfoSuccess(info) {
|
|
this._nodeInfo = info.data;
|
|
this.fetchPassPhrase()
|
|
}
|
|
|
|
fetchNodeInfoFailed(err) {
|
|
console.log(err);
|
|
}
|
|
|
|
fetchAccountInfoSuccess(res) {
|
|
this._accountInfo = res.data;
|
|
if(this.accountInfo?.sequence?.nonce)
|
|
this.accountInfo.sequence.nonce = parseInt(this.accountInfo.sequence.nonce) || 0
|
|
}
|
|
|
|
get sharedData() {
|
|
return this._sharedData.map(elem => ({
|
|
data: elem.data.map(item => ({
|
|
label: labelMap[item.label],
|
|
value: item.value,
|
|
}))
|
|
}));
|
|
};
|
|
|
|
get transactionsInfo() {
|
|
return this._transactionsInfo.map(item => {
|
|
return {
|
|
id: item.id,
|
|
sender_avatar: item.asset.recipientAddress && generateSvgAvatar(item.senderPublicKey),
|
|
avatar_size: 24,
|
|
transaction: item.asset.features.map(asset => {
|
|
return {
|
|
transaction_id: item.id,
|
|
address: item.asset.recipientAddress && cryptography.bufferToHex(cryptography.getAddressFromPublicKey(cryptography.hexToBuffer(item.senderPublicKey))),
|
|
value: asset.value,
|
|
label: labelMap[asset.label] || asset.label
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
get decryptedAccountData() {
|
|
const allAccountData=this._accountData.concat(this.accountFeatures.filter(item=>!this._accountData.find(elem=>elem.label===item.label)))
|
|
return allAccountData.map((elem) => {
|
|
const initialData={
|
|
...elem,
|
|
key: elem.label,
|
|
label: labelMap[elem.label] || elem.label,
|
|
status: '',
|
|
value: '',
|
|
seed: ''
|
|
}
|
|
if(!this._accountData.find(item=>item.label===elem.label)) {
|
|
return {
|
|
...initialData,
|
|
status: statusMap.blockchained,
|
|
value: elem.value
|
|
}
|
|
}
|
|
const [seed, value] = cryptography.decryptMessageWithPassphrase(elem.value, elem.value_nonce, this.passPhrase, this.pubKey).split(':');
|
|
const hashValue=cryptography.hash(Buffer.concat([Buffer.from(seed, 'utf8'), cryptography.hash(value, 'utf8')])).toString('hex')
|
|
if(!this.accountFeatures.find(item=>item.label===elem.label)) {
|
|
return {
|
|
...initialData,
|
|
status: statusMap.stored,
|
|
value,
|
|
seed
|
|
}
|
|
}
|
|
if(this.accountFeatures.find(item=>item.label===elem.label).value!==hashValue) {
|
|
return {
|
|
...initialData,
|
|
status: statusMap.incorrect,
|
|
value,
|
|
seed
|
|
}
|
|
}
|
|
return {
|
|
...initialData,
|
|
status: statusMap.completed,
|
|
value,
|
|
seed
|
|
}
|
|
})
|
|
}
|
|
|
|
get firstName() {
|
|
return this.decryptedAccountData.find(item => item.key === 'firstname')?.value
|
|
}
|
|
|
|
get lastName() {
|
|
return this.decryptedAccountData.find(item => item.key === 'secondname')?.value
|
|
}
|
|
|
|
get accountName() {
|
|
return this.firstName || this.lastName || this.pubKey
|
|
}
|
|
|
|
get keysArray() {
|
|
return this._keysArray;
|
|
}
|
|
|
|
get passPhrase() {
|
|
return this._passPhrase
|
|
}
|
|
|
|
get accountData() {
|
|
return this._accountData
|
|
};
|
|
|
|
get accountInfo() {
|
|
return this._accountInfo;
|
|
}
|
|
|
|
get nodeInfo() {
|
|
return this._nodeInfo;
|
|
}
|
|
|
|
get addressAndPubKey() {
|
|
return cryptography.getAddressAndPublicKeyFromPassphrase(this.passPhrase);
|
|
}
|
|
|
|
get pubKey() {
|
|
return this.addressAndPubKey.publicKey.toString('hex');
|
|
}
|
|
|
|
get address() {
|
|
return this.addressAndPubKey.address.toString('hex')
|
|
}
|
|
|
|
get tokenKey() {
|
|
const stringToSign = this.nodeInfo.networkIdentifier + this.nodeInfo.lastBlockID;
|
|
if(!stringToSign)
|
|
return '';
|
|
const sign = cryptography.signDataWithPassphrase(Buffer.from(stringToSign, 'hex'), this.passPhrase).toString('hex')
|
|
return this.pubKey + ':' +sign
|
|
}
|
|
|
|
get accountIdentity() {
|
|
return this.accountInfo?.identity || {};
|
|
}
|
|
|
|
get accountFeatures() {
|
|
return this.accountIdentity?.features || [];
|
|
}
|
|
|
|
get accountFeaturesMap() {
|
|
return this.accountFeatures.reduce((acc, item) => ({
|
|
...acc,
|
|
[item.label]: item.value
|
|
}), {})
|
|
}
|
|
|
|
get loading() {
|
|
return this._loading;
|
|
}
|
|
|
|
set loading(value) {
|
|
this._loading = value;
|
|
}
|
|
}
|
|
|
|
export const store = new Store();
|