keystore_wdc
Version:
``` npm i keystore_wdc; const KeyStore = require('keystore_wdc'); const ks = new KeyStore(); ``` #### 生成keystore ``` async function create(){ const keystore = await ks.Create("your password"); } ``` * 返回keystore，密码格式不正确返回-1。
637 lines (579 loc) • 27.6 kB
JavaScript
"use strict";
const AccountHandle = require('./account-handle');
const aesjs = require('./aes-js');
const keccak256 = require('./sha3').keccak256;
const argon2b = require('argon2-browser');
const fs = require('fs');
const crypto = require('crypto');
const uuidV4 = require('uuid/v4');
const path = __dirname + "/../../../keystore/main";
const testpath = __dirname + "/../../../keystore/test";
const bs58 = require('./base58');
const Decimal = require('./decimal.js');
const nacl = require('./nacl.min.js');
const BN = require('bn.js');
var Uint64BE = require("./int64-buffer").Uint64BE;
var uint32 = require('uint32');
const Transaction = require('./transaction');
class KeyStore {
constructor() {
}
async argon2(s1, salt){
return Buffer.from((await argon2b.hash({
pass: s1,
time: 4,
mem: 20480,
hashLen: 32,
parallelism: 2,
type: argon2b.ArgonType.Argon2id,
salt: salt
})).hashHex, 'hex')
}
setArgon2(fn){
this.argon2 = fn
}
async Create (pwd) {
try {
if(pwd.length>20 || pwd.length<8){
return -1;
}
let keyStore = {};
const account = new AccountHandle().createAccount();
//地址
keyStore.address = account.addr;
keyStore.crypto = {};
//使用的加密算法，默认为aes-256-ctr
keyStore.crypto.cipher = "aes-256-ctr";
//keyStore.crypto.ciphertext = "";
keyStore.crypto.cipherparams = {};
//算法所需的参数，随机生成
keyStore.crypto.cipherparams.iv = crypto.randomBytes(16).toString('hex'); // must be 128 bit, random
//const aesCtr = new aesjs.ModeOfOperation.ctr(key_256, new aesjs.Counter(5));
//var encryptedBytes = aesCtr.encrypt(textBytes);
//密钥加密方法
keyStore.kdf = "Argon2id";
//Argon2id的参数，分别是散列计算的迭代次数，必须使用的存储器的大小以及可以并行计算散列的CPU数量
keyStore.kdfparams = {};
keyStore.kdfparams.timeCost = 4;
keyStore.kdfparams.memoryCost = 20480;
keyStore.kdfparams.parallelism = 2;
//Argon2id哈希计算使用的盐值，随机生成32
keyStore.kdfparams.salt = crypto.randomBytes(32).toString('hex'); // random
//keystore格式的版本号，默认为1 2019.12.19日更新keystore版本2
keyStore.version = "2";
//私钥加密
// const salt = Buffer.from(keyStore.kdfparams.salt, 'hex');
const salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
// const p1 = Buffer.from(pwd, 'ascii').toString('hex');
const p1 = Buffer.from(pwd, 'ascii');
let totalLength = salt.length+p1.length;
const s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
// const s1 = keyStore.kdfparams.salt + p1;
const derivedKey = Buffer.from(await this.argon2(s1, salt));
const vi = Buffer.from(keyStore.crypto.cipherparams.iv, 'hex');
const aesCtr = new aesjs.ModeOfOperation.ctr(derivedKey, new aesjs.Counter(vi));
let _prikey = this.Bytes2Str(account.secretKey).substring(0,64);
let prikey = Buffer.from(_prikey,'hex');
const encryptedBytes = aesCtr.encrypt(prikey);
//加密过的私钥
keyStore.crypto.ciphertext = aesjs.utils.hex.fromBytes(encryptedBytes);
//用来比较解密密钥与口令的
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
keyStore.mac = keccak256(dc_buf);
//这是UUID，可以直接通过程序计算得到
keyStore.id = uuidV4();
return keyStore;
} catch (error) {
return 5000;
}
}
async Import (pwd,privateKey) {
try {
if(pwd.length>20 || pwd.length<8){
return -1;
}
let keyStore = {};
//地址
keyStore.address = this.pubkeyHashToaddress(this.pubkeyToPubkeyHash(this.prikeyToPubkey(privateKey)),1);
keyStore.crypto = {};
//使用的加密算法，默认为aes-256-ctr
keyStore.crypto.cipher = "aes-256-ctr";
//keyStore.crypto.ciphertext = "";
keyStore.crypto.cipherparams = {};
//算法所需的参数，随机生成
keyStore.crypto.cipherparams.iv = crypto.randomBytes(16).toString('hex'); // must be 128 bit, random
//const aesCtr = new aesjs.ModeOfOperation.ctr(key_256, new aesjs.Counter(5));
//var encryptedBytes = aesCtr.encrypt(textBytes);
//密钥加密方法
keyStore.kdf = "Argon2id";
//Argon2id的参数，分别是散列计算的迭代次数，必须使用的存储器的大小以及可以并行计算散列的CPU数量
keyStore.kdfparams = {};
keyStore.kdfparams.timeCost = 4;
keyStore.kdfparams.memoryCost = 20480;
keyStore.kdfparams.parallelism = 2;
//Argon2id哈希计算使用的盐值，随机生成32
keyStore.kdfparams.salt = crypto.randomBytes(32).toString('hex'); // random
//keystore格式的版本号，默认为1 2019.12.19日更新keystore版本2
keyStore.version = "2";
//私钥加密
// const salt = Buffer.from(keyStore.kdfparams.salt, 'hex');
const salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
// const p1 = Buffer.from(pwd, 'ascii').toString('hex');
const p1 = Buffer.from(pwd, 'ascii');
let totalLength = salt.length+p1.length;
const s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
// const s1 = keyStore.kdfparams.salt + p1;
const derivedKey = Buffer.from(await this.argon2(s1, salt))
const vi = Buffer.from(keyStore.crypto.cipherparams.iv, 'hex');
const aesCtr = new aesjs.ModeOfOperation.ctr(derivedKey, new aesjs.Counter(vi));
let prikey = Buffer.from(privateKey,'hex');
const encryptedBytes = aesCtr.encrypt(prikey);
//加密过的私钥
keyStore.crypto.ciphertext = aesjs.utils.hex.fromBytes(encryptedBytes);
//用来比较解密密钥与口令的
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
keyStore.mac = keccak256(dc_buf);
//这是UUID，可以直接通过程序计算得到
keyStore.id = uuidV4();
return keyStore;
} catch (error) {
return 5000;
}
}
EncryptSecretKey() {
}
//keystore路径和密码获取私钥
async DecryptSecretKey(addr, pwd) {
const keyStore = this.Read(addr);
if(keyStore == null) return null;
let salt;
let p1;
let totalLength;
let s1;
if(keyStore.version == 2){
salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
p1 = Buffer.from(pwd, 'ascii');
totalLength = salt.length+p1.length;
s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
}else{
salt = Buffer.from(keyStore.kdfparams.salt, 'hex');
p1 = Buffer.from(pwd, 'ascii').toString('hex');
s1 = keyStore.kdfparams.salt + p1;
}
const derivedKey = Buffer.from(await this.argon2(s1, salt));
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
const mac = keccak256(dc_buf);
if(mac != keyStore.mac) return null;
//私钥解密
const vi = Buffer.from(keyStore.crypto.cipherparams.iv, 'hex');
const aesCtr = new aesjs.ModeOfOperation.ctr(derivedKey, new aesjs.Counter(vi));
var encryptedBytes = aesjs.utils.hex.toBytes(keyStore.crypto.ciphertext);
var decryptedBytes = aesCtr.decrypt(encryptedBytes);
return decryptedBytes;
}
Save (keystore,net) {
let newpath;
if(net == "main"){
newpath = path;
}else{
newpath = testpath;
}
if(!fs.existsSync(newpath)) fs.mkdirSync(newpath);
let time=new Date().getTime();
const filePath = newpath + "/" + keystore.address+"@"+time;
const content = JSON.stringify(keystore, null, 4);
fs.writeFile(filePath, content, {flag: 'w'}, function (err) {
if(err) {
console.error(err);
} else {
console.log('keystore create success');
}
});
}
Read (fileName) {
const filePath = path + "/" + fileName;
if(fs.existsSync(filePath) == false) return null;
const result = JSON.parse(fs.readFileSync( filePath));
return result;
}
Readfull (filefullName){
if(fs.existsSync(filefullName) == false) return null;
const result = JSON.parse(fs.readFileSync( filefullName));
return result;
}
async DecryptSecretKeyfull(keyStore, pwd) {
try{
if(keyStore == null) return 5000;
let salt;
let p1;
let totalLength;
let s1;
if(keyStore.version == 2){
salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
p1 = Buffer.from(pwd, 'ascii');
totalLength = salt.length+p1.length;
s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
}else{
salt = Buffer.from(keyStore.kdfparams.salt, 'hex');
p1 = Buffer.from(pwd, 'ascii').toString('hex');
s1 = keyStore.kdfparams.salt + p1;
}
const derivedKey = Buffer.from(await this.argon2(s1, salt));
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
const mac = keccak256(dc_buf);
if(mac != keyStore.mac) return 5000;
//私钥解密
const vi = Buffer.from(keyStore.crypto.cipherparams.iv, 'hex');
const aesCtr = new aesjs.ModeOfOperation.ctr(derivedKey, new aesjs.Counter(vi));
var encryptedBytes = aesjs.utils.hex.toBytes(keyStore.crypto.ciphertext);
var decryptedBytes=[];
decryptedBytes = aesCtr.decrypt(encryptedBytes);
var str="";
var hexString = "0123456789ABCDEF";
for(var i=0; i<decryptedBytes.length; i++)
{
var tmp = decryptedBytes[i].toString(16);
if(tmp.length == 1)
{
tmp = "0" + tmp;
}
str += tmp;
}
return str;
}catch (error) {
return 5000;
}
}
async verifySecretKey(keyStore, pwd) {
if(keyStore == null) return null;
let salt;
let p1;
let totalLength;
let s1;
if(keyStore.version == 2){
salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
p1 = Buffer.from(pwd, 'ascii');
totalLength = salt.length+p1.length;
s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
}else{
salt = Buffer.from(keyStore.kdfparams.salt, 'hex');
p1 = Buffer.from(pwd, 'ascii').toString('hex');
s1 = keyStore.kdfparams.salt + p1;
}
const derivedKey = Buffer.from(await this.argon2(s1, salt));
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
const mac = keccak256(dc_buf);
if(mac != keyStore.mac){
return null;
}else{
return 1;
}
}
buf2hex(buffer) { // buffer is an ArrayBuffer
return Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('');
}
Hex2Array(hex) {
// let ret = new Array();
// for(let i=0; i<hex.length; i+=2) {
// ret.push(parseInt(hex.substr(i,2), 16));
// }
// return ret;
return Buffer.from(hex, 'hex');
}
addressToPubkeyHash(address){
try{
let _r5;
if(address.indexOf("1") == 0){
_r5 = new bs58().decode(address);
}else{
_r5 = new bs58().decode(address.substr(2));
}
let r5 = this.buf2hex(_r5);
let r2 = r5.substring(0,r5.length-8);
let r1 = r2.substring(2,r2.length)
return r1;
}catch (error) {
return 5000;
}
}
pubkeyToPubkeyHash(pubkey){
try{
let pub256 = keccak256(Buffer.from(pubkey,'hex'));
let bufPub256 = Buffer.from(pub256, 'hex');
let r1 = crypto.createHash('ripemd160').update(bufPub256).digest('hex');
return r1;
}catch (error) {
return 5000;
}
}
pubkeyHashToaddress(pubkeyHash,type){
try{
let r1 = Buffer.from(pubkeyHash,'hex');
let r2 = "00"+pubkeyHash;
let a = Buffer.from(r1, 'hex');
let b = keccak256(a);
let c =Buffer.from(b, 'hex');
let r3 = keccak256(c);
let b4 = r3.substring(0,8);
let r5 = r2+b4;
let r6 = new bs58().encode(this.Hex2Array(r5));
if(type == 1){
return "WX"+r6;
}else if(type == 2){
return "WR"+r6;
}
return 5000;
} catch (error) {
return 5000;
}
}
verifyAddress(address){
try{
if(address==""||address==null){
return -1;
}
if(address.indexOf("1") == 0 || address.indexOf("WX") == 0 || address.indexOf("WR") == 0){
let _r5;
if( address.indexOf("WX") == 0 || address.indexOf("WR") == 0){
_r5 = new bs58().decode(address.substr(2));
}else{
_r5 = new bs58().decode(address);
}
let a = Buffer.from(this.addressToPubkeyHash(address),'hex');
let b = keccak256(a)
let c =Buffer.from(b, 'hex');
let r3 = keccak256(c);
let b4 = r3.substring(0,8);
let _b4 = this.Bytes2Str(_r5).substring(42,50);
if(b4 == _b4){
return 0;
}else{
return -2;
}
}else{
return -1;
}
} catch (error) {
return 5000;
}
}
prikeyToPubkey(prikey){
try{
const keyPair = new AccountHandle().createKeyPairBySecretKey(this.Hex2Array(prikey));
return this.buf2hex(keyPair.publicKey);
} catch (error) {
return 5000;
}
}
async updateKeystoreVersion1to2(ks,pwd){
let result = await this.modifyPassword(ks,pwd,pwd);
return result;
}
async modifyPassword(ks,pwd,newpwd){
try{
if(newpwd.length>20 || newpwd.length<8){
return -1;
}
let _prikey = await this.DecryptSecretKeyfull(ks, pwd);
if(_prikey.length == 128){
_prikey = _prikey.substring(0,64)
}
let keyStore = {};
//地址
keyStore.address =new AccountHandle().pubKeyToaddress(Buffer.from(this.prikeyToPubkey(_prikey), 'hex'),"WX");
keyStore.crypto = {};
//使用的加密算法，默认为aes-256-ctr
keyStore.crypto.cipher = "aes-256-ctr";
//keyStore.crypto.ciphertext = "";
keyStore.crypto.cipherparams = {};
//算法所需的参数，随机生成
keyStore.crypto.cipherparams.iv = crypto.randomBytes(16).toString('hex'); // must be 128 bit, random
//const aesCtr = new aesjs.ModeOfOperation.ctr(key_256, new aesjs.Counter(5));
//var encryptedBytes = aesCtr.encrypt(textBytes);
//密钥加密方法
keyStore.kdf = "Argon2id";
//Argon2id的参数，分别是散列计算的迭代次数，必须使用的存储器的大小以及可以并行计算散列的CPU数量
keyStore.kdfparams = {};
keyStore.kdfparams.timeCost = 4;
keyStore.kdfparams.memoryCost = 20480;
keyStore.kdfparams.parallelism = 2;
//Argon2id哈希计算使用的盐值，随机生成32
keyStore.kdfparams.salt = crypto.randomBytes(32).toString('hex'); // random
//keystore格式的版本号，默认为1
keyStore.version = "2";
//私钥加密
const salt = Buffer.from(keyStore.kdfparams.salt, 'ascii');
const p1 = Buffer.from(newpwd, 'ascii');
let totalLength = salt.length+p1.length;
const s1 = Buffer.concat([salt, p1], totalLength).toString('ascii');
const derivedKey = Buffer.from(await this.argon2(s1, salt));
const vi = Buffer.from(keyStore.crypto.cipherparams.iv, 'hex');
const aesCtr = new aesjs.ModeOfOperation.ctr(derivedKey, new aesjs.Counter(vi));
let prikey = Buffer.from(_prikey,'hex');
const encryptedBytes = aesCtr.encrypt(prikey);
//加密过的私钥
keyStore.crypto.ciphertext = aesjs.utils.hex.fromBytes(encryptedBytes);
//用来比较解密密钥与口令的
const dc = derivedKey.toString('hex') + keyStore.crypto.ciphertext;
const dc_buf = Buffer.from(dc, 'hex');
keyStore.mac = keccak256(dc_buf);
//这是UUID，可以直接通过程序计算得到
keyStore.id = uuidV4();
return keyStore;
}catch(error){
return 5000;
}
}
async keystoreToPubkey(keyStore,pwd){
try{
return this.prikeyToPubkey(await this.DecryptSecretKeyfull(keyStore, pwd));
} catch (error) {
return 5000;
}
}
Bytes2Str(arr){
var str = "";
for(var i=0; i<arr.length; i++){
var tmp = arr[i].toString(16);
if(tmp.length == 1){
tmp = "0" + tmp;
}
str += tmp;
}
return str;
}
//Ripemd160哈希
Ripemd160(pubkey){
return new Transaction().Ripemd160(pubkey);
}
//签名
nftSign(prikeyStr,signMessage){
//签名数据
let secretKey = Buffer.from(prikeyStr + this.prikeyToPubkey(prikeyStr), 'hex');
let transaction = Buffer.from(signMessage);
let sigall = nacl.sign(transaction, secretKey);
let sigHex = this.Bytes2Str(sigall).substring(0, 128);
return sigHex;
}
//校验签名
checkSign(signTransaction,publicKey,signMessage) {
try {
let isSign = nacl.sign.detached.verify(Buffer.from(signMessage), Buffer.from(signTransaction, 'hex'), Buffer.from(publicKey, 'hex'));
if (!isSign) {
return 5100;
}
return 2000;
} catch (error) {
console.log(error);
return 5000;
}
}
//转账
ClientToTransferAccount(fromPubkeyStr,toPubkeyHashStr,amount,prikeyStr,nonce){
return new Transaction().ClientToTransferAccount(fromPubkeyStr,toPubkeyHashStr,amount,prikeyStr,nonce);
}
AnalysisTransaction(msg){
return new Transaction().AnalysisTransaction(msg);
}
Sign(msg,prikey){
return new Transaction().Sign(msg,prikey+this.prikeyToPubkey(prikey));
}
AnalysisRawTransaction(transaction){
return new Transaction().AnalysisRawTransaction(transaction);
}
// //存证
// ClientToTransferProve(fromPubkeyStr,nonce,payloadbyte,prikeyStr){
// return new Transaction().ClientToTransferProve(fromPubkeyStr,nonce,payloadbyte,prikeyStr);
// }
// //投票
// ClientToTransferVote(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr){
// return new Transaction().ClientToTransferVote(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr);
// }
// //撤回投票
// ClientToTransferVoteWithdraw(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr,txid){
// return new Transaction().ClientToTransferVoteWithdraw(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr,txid);
// }
// //抵押
// ClientToTransferMortgage(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr){
// return new Transaction().ClientToTransferMortgage(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr);
// }
// //撤回抵押
// ClientToTransferMortgageWithdraw(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr,txid){
// return new Transaction().ClientToTransferMortgageWithdraw(fromPubkeyStr,toPubkeyHashStr,amount,nonce,prikeyStr,txid);
// }
// //资产定义
// CreateSignToDeployforRuleAsset(fromPubkeyStr,nonce,prikeyStr,code,offering,owner,allowincrease,info){
// return new Transaction().CreateSignToDeployforRuleAsset(fromPubkeyStr,nonce,prikeyStr,code,offering,owner,allowincrease,info);
// };
// //更换所有者公钥哈希
// CreateSignToDeployforAssetChangeowner(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,newOwnerPubkeyhash){
// return new Transaction().CreateSignToDeployforAssetChangeowner(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,newOwnerPubkeyhash);
// }
// //资产转发
// CreateSignToDeployforRuleTransfer(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_from,payload_to,payload_amount){
// return new Transaction().CreateSignToDeployforRuleTransfer(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_from,payload_to,payload_amount);
// }
// //增发
// CreateSignToDeployforRuleAssetIncreased(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_amount){
// return new Transaction().CreateSignToDeployforRuleAssetIncreased(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_amount);
// }
// //部署哈希时间锁定
// CreateHashTimeBlockForDeploy(fromPubkeyStr,nonce,prikeyStr,payload_assetHexStr,payload_pubkeyHashHexStr){
// return new Transaction().CreateHashTimeBlockForDeploy(fromPubkeyStr,nonce,prikeyStr,payload_assetHexStr,payload_pubkeyHashHexStr);
// }
// //哈希时间锁定转发资产
// CreateHashTimeBlockTransferForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_value,payload_hashresult,payload_timestamp){
// return new Transaction().CreateHashTimeBlockTransferForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_value,payload_hashresult,payload_timestamp);
// }
// //哈希时间锁定获得锁定资产
// CreateHashTimeBlockGetForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_transferhash,origintext){
// return new Transaction().CreateHashTimeBlockGetForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_transferhash,origintext);
// }
// //部署哈希高度锁定
// CreateHashHeightBlockForDeploy(fromPubkeyStr,nonce,prikeyStr,payload_assetHexStr,payload_pubkeyHashHexStr){
// return new Transaction().CreateHashHeightBlockForDeploy(fromPubkeyStr,nonce,prikeyStr,payload_assetHexStr,payload_pubkeyHashHexStr);
// }
// //哈希高度锁定转发资产
// CreateHashHeightBlockTransferForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_value,payload_hashresult,payload_height){
// return new Transaction().CreateHashHeightBlockTransferForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_value,payload_hashresult,payload_height);
// }
// //哈希高度锁定获得锁定资产
// CreateHashHeightBlockGetForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_transferhash,origintext){
// return new Transaction().CreateHashHeightBlockGetForDeploy(fromPubkeyStr,toPubkeyHashStr,nonce,prikeyStr,payload_transferhash,origintext);
// }
// //部署多签(签发者构建)
// CreateMultipleForRuleFirst(fromPubkeyStr,nonceNum,prikeyStr,payload_asset160hash,payload_m,payload_n,payload_pubkeyHashasBytesArray){
// return new Transaction().CreateMultipleForRuleFirst(fromPubkeyStr,nonceNum,prikeyStr,payload_asset160hash,payload_m,payload_n,payload_pubkeyHashasBytesArray);
// }
// //部署多签(其他人签名)
// CreateMultipleToDeployforRuleOther(signTransaction,rawTransaction,transaction_pubkey,fromPubkeyStr,prikeyStr,signTransactionArray,fromArray){
// return new Transaction().CreateMultipleToDeployforRuleOther(signTransaction,rawTransaction,transaction_pubkey,fromPubkeyStr,prikeyStr,signTransactionArray,fromArray);
// }
// //多签部署组装事务（用于广播）
// CreateMultipleForRuleSplice(rawTransaction,fromArray,signTransactionArray,prikeyStr){
// return new Transaction().CreateMultipleForRuleSplice(rawTransaction,fromArray,signTransactionArray,prikeyStr);
// }
// //多签转账（签发者构建）
// CreateMultisignatureForTransferFirst(fromPubkeyStr,toPubkeyHashStr,nonceNum,prikeyStr,payload_origin,payload_dest,payload_fromBytesArray,payload_to,payload_value,payload_pubkeyHashasBytesArray){
// return new Transaction().CreateMultisignatureForTransferFirst(fromPubkeyStr,toPubkeyHashStr,nonceNum,prikeyStr,payload_origin,payload_dest,payload_fromBytesArray,payload_to,payload_value,payload_pubkeyHashasBytesArray);
// }
// //多签转账(其他人签名)
// CreateMultisignatureToDeployforRuleOther(signTransaction,rawTransaction,transaction_pubkey,fromPubkeyStr,prikeyStr,signTransactionArray,fromArray){
// return new Transaction().CreateMultisignatureToDeployforRuleOther(signTransaction,rawTransaction,transaction_pubkey,fromPubkeyStr,prikeyStr,signTransactionArray,fromArray);
// }
// //多签转账组装事务（用于广播）
// CreateMultisignatureForTransferSplice(rawTransaction,fromArray,signTransactionArray,prikeyStr){
// return new Transaction().CreateMultisignatureForTransferSplice(rawTransaction,fromArray,signTransactionArray,prikeyStr);
// }
//定额条件比例支付部署
//定额条件比例支付转入
//定额条件比例支付转出
Check() {
}
}
module.exports = KeyStore;