首次放到 git
This commit is contained in:
commit
16cca302b7
60
Account.js
Normal file
60
Account.js
Normal file
@ -0,0 +1,60 @@
|
|||||||
|
'use strict'
|
||||||
|
const Coins = {}
|
||||||
|
Coins.TIC = require('./tic.js').TIC;
|
||||||
|
Coins.ETH = require('./eth.js').ETH;
|
||||||
|
Coins.ERC20 = require('./eth.js').ERC20;
|
||||||
|
Coins.BTC = require('./btc.js').BTC;
|
||||||
|
|
||||||
|
class Account {
|
||||||
|
constructor(coinType,privateKey,contractAddress){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return new Coins[coinType.toUpperCase()](privateKey)
|
||||||
|
else
|
||||||
|
return new Coins.ERC20(privateKey,contractAddress)
|
||||||
|
}
|
||||||
|
static generateNewAccount(coinType){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc')
|
||||||
|
return Coins[coinType.toUpperCase()].generateNewAccount()
|
||||||
|
return Coins.ETH.generateNewAccount()
|
||||||
|
}
|
||||||
|
static fromMnemonic(coinType,mnemonic){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return Coins[coinType.toUpperCase()].fromMnemonic(mnemonic)
|
||||||
|
return Coins.ETH.fromMnemonic(mnemonic)
|
||||||
|
}
|
||||||
|
static fromPrivateKey(coinType,privateKey,contractAddress){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return new Coins[coinType.toUpperCase()](privateKey)
|
||||||
|
return new Coins.ERC20(privateKey,contractAddress)
|
||||||
|
}
|
||||||
|
static async fromOfficalWallet(encryptedWallet,key){
|
||||||
|
return await Coins.ETH.fromEncryptedWallet(encryptedWallet,key)
|
||||||
|
}
|
||||||
|
static async getBalance(coinType,address,contractAddress){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return await Coins[coinType.toUpperCase()].getBalance(address)
|
||||||
|
return await Coins.ERC20.getBalance(address,contractAddress)
|
||||||
|
}
|
||||||
|
static async getActions(coinType,address,contractAddress){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return await Coins[coinType.toUpperCase()].getActions(address)
|
||||||
|
return await Coins.ERC20.getActions(address,contractAddress)
|
||||||
|
}
|
||||||
|
static decrypt(coinType,encryptedWallet,key){
|
||||||
|
if(coinType === 'tic' || coinType === 'btc' || coinType === 'eth')
|
||||||
|
return Coins[coinType.toUpperCase()].decrypt(encryptedWallet,key)
|
||||||
|
return Coins.ETH.decrypt(encryptedWallet,key)
|
||||||
|
}
|
||||||
|
static isValidAddress(coinType, address){
|
||||||
|
if(!coinType || !address) return null
|
||||||
|
switch(coinType){
|
||||||
|
case "tic": return Coins.TIC.isValidAddress(address)
|
||||||
|
case "btc": return Coins.BTC.isValidAddress(address)
|
||||||
|
default: return Coins.ETH.isValidAddress(address)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
Account
|
||||||
|
}
|
||||||
12
README.md
Normal file
12
README.md
Normal file
@ -0,0 +1,12 @@
|
|||||||
|
---
|
||||||
|
title: Toolset for Cryptocurrency
|
||||||
|
tags:
|
||||||
|
- bitcoin
|
||||||
|
- ethereum
|
||||||
|
- tic
|
||||||
|
---
|
||||||
|
to start
|
||||||
|
> git clone https://github.com/chaosBreaking/BitHoole.git
|
||||||
|
|
||||||
|
for use
|
||||||
|
> account = require('BitHoole')
|
||||||
151
btc.js
Normal file
151
btc.js
Normal file
@ -0,0 +1,151 @@
|
|||||||
|
'use strict'
|
||||||
|
|
||||||
|
const axios = require('axios');
|
||||||
|
const HDNode = require('./utils/hdnode');
|
||||||
|
const bitcoinjs = require('bitcoinjs-lib');
|
||||||
|
// const bitcore = require('tic.common').Bitcore;
|
||||||
|
const ticCommon = require('tic.common').Crypto;
|
||||||
|
const BTC_NODE = require('./netConfig').BTC_NODE;
|
||||||
|
const BTC_NODE2 = require('./netConfig').BTC_NODE2;
|
||||||
|
const BTC_TXFEE = 30;
|
||||||
|
|
||||||
|
class BTC {
|
||||||
|
constructor(privateKey){
|
||||||
|
if(!ticCommon.isSeckey(privateKey)) throw new Error('Invalid PrivateKey')
|
||||||
|
var publicKey = ticCommon.seckey2pubkey(privateKey)
|
||||||
|
Object.defineProperties(this,{
|
||||||
|
"privateKey" : {
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
value : privateKey
|
||||||
|
},
|
||||||
|
"publicKey": {
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
value : ticCommon.seckey2pubkey(privateKey,{coin:"BTC"})
|
||||||
|
},
|
||||||
|
"address" : {
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
value : ticCommon.pubkey2address(publicKey,{coin:"BTC"})
|
||||||
|
},
|
||||||
|
"url" : {
|
||||||
|
enumerable : true,
|
||||||
|
get: function() { return this._url; },
|
||||||
|
set: function(url) {
|
||||||
|
if (typeof(url) !== 'string') { throw new Error('invalid url'); }
|
||||||
|
this._url = url;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"defaultGas":{
|
||||||
|
enumerable: true,
|
||||||
|
get: function() { return this._defaultGasFee; },
|
||||||
|
set: function(value) {
|
||||||
|
if (typeof(value) !== 'number') { throw new Error('invalid defaultGasFee'); }
|
||||||
|
this._defaultGasFee = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})
|
||||||
|
this._url = BTC_NODE;
|
||||||
|
this._defaultGasFee = BTC_TXFEE;
|
||||||
|
|
||||||
|
}
|
||||||
|
static generateNewAccount(){
|
||||||
|
var mnemonic = ticCommon.randomSecword()
|
||||||
|
return Object.assign(new BTC(ticCommon.secword2keypair(mnemonic, {coin:"BTC"}).seckey),{mnemonic : mnemonic})
|
||||||
|
}
|
||||||
|
static fromMnemonic(mnemonic){
|
||||||
|
HDNode.isValidMnemonic(mnemonic)
|
||||||
|
return Object.assign(new BTC(ticCommon.secword2keypair(mnemonic, {coin:"BTC"}).seckey),{mnemonic:mnemonic})
|
||||||
|
}
|
||||||
|
static async getBalance(address){
|
||||||
|
return (await axios.get(`${BTC_NODE}/addrs/${address}/balance`)).data.balance
|
||||||
|
}
|
||||||
|
static async getActions(address){
|
||||||
|
return (await axios.get(`${BTC_NODE}/addrs/${address}`)).data.txrefs
|
||||||
|
}
|
||||||
|
static async getUTXO(address){
|
||||||
|
// console.log(`${BTC_NODE2}/unspent?active=${address}`,`${BTC_NODE2}/unspent?active=${address}`)
|
||||||
|
try {
|
||||||
|
return (await axios.get(`${BTC_NODE2}/unspent?active=${address}`)).data.unspent_outputs
|
||||||
|
} catch (error) {
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
static encrypt(data, key){
|
||||||
|
if(!data || !key) throw new Error('Required Params Missing')
|
||||||
|
return ticCommon.encrypt(data,key)
|
||||||
|
}
|
||||||
|
static decrypt(data, key){
|
||||||
|
return ticCommon.decrypt(data, key, {format:"json"}) //return null for wrong key
|
||||||
|
}
|
||||||
|
static isValidAddress(address){
|
||||||
|
return address.length == 34 && address[0] == '1'
|
||||||
|
}
|
||||||
|
async sendTransaction(toAddress, amount, option = {gasFee : BTC_TXFEE}){
|
||||||
|
let set = bitcoinjs.ECPair.fromPrivateKey(Buffer.from(this.privateKey,'hex'));//导入私钥用于签名
|
||||||
|
let txb = new bitcoinjs.TransactionBuilder();//初始化交易对象
|
||||||
|
let tx = await BTC.getUTXO('1DEP8i3QJCsomS4BSMY2RpU1upv62aGvhD')
|
||||||
|
if(!tx) return null
|
||||||
|
var tot = 0;//用于记录UTXO总量
|
||||||
|
amount+=1e4;//消费金额是转出金额加上10000的矿工费
|
||||||
|
txb.setVersion(1);//设置交易版本号
|
||||||
|
for(var i=0;i<tx.length;i++){ //将UTXO的相关信息依次填入交易体中
|
||||||
|
txb.addInput(tx[i].tx_hash_big_endian, tx[i].tx_output_n);
|
||||||
|
tot+=tx[i].value;
|
||||||
|
}
|
||||||
|
|
||||||
|
txb.addOutput(toAddress, amount-1e4);//填入转出目标地址和对应的金额
|
||||||
|
txb.addOutput(this.address, tot-amount); //填入找零地址，也就是原地址，并填入把找零金额
|
||||||
|
for(var i=0;i<tx.length;i++){//对交易体中的UTXO依次签名
|
||||||
|
txb.sign(i, set);
|
||||||
|
}
|
||||||
|
// let txBody = txb.buildIncomplete().toHex()
|
||||||
|
let data = {tx : txb.buildIncomplete().toHex()}
|
||||||
|
try {
|
||||||
|
let res = await axios.post(`${BTC_NODE}/txs/push`,data)
|
||||||
|
return res
|
||||||
|
} catch (error) {
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
// async sendTransaction(toAddress, amount, option = {gasFee : BTC_TXFEE}){
|
||||||
|
// var privateKey = bitcore.PrivateKey(this.privateKey)
|
||||||
|
// var ecdsa = new bitcore.crypto.ECDSA();
|
||||||
|
|
||||||
|
// var newtx = {
|
||||||
|
// inputs: [{addresses: [this.address]}],
|
||||||
|
// outputs: [{addresses: [toAddress], value: amount}]
|
||||||
|
// };
|
||||||
|
// try {
|
||||||
|
// var tmptx = (await axios.post('https://api.blockcypher.com/v1/btc/test3/txs/new',newtx)).data;
|
||||||
|
// tmptx.pubkeys = [];
|
||||||
|
// tmptx.pubkeys.push(privateKey.toPublicKey().toString("hex"))
|
||||||
|
// ecdsa.hashbuf = bitcore.crypto.Hash.sha256(new Buffer(tmptx.tosign));
|
||||||
|
// ecdsa.privkey = privateKey;
|
||||||
|
// ecdsa.pubkey = privateKey.toPublicKey();
|
||||||
|
// ecdsa.deterministicK();
|
||||||
|
// let signatureExpected = ecdsa.sign();
|
||||||
|
// tmptx.signatures = [Buffer.from(signatureExpected.sig.toDER()).toString('hex')]
|
||||||
|
// let res = (await axios.post('https://api.blockcypher.com/v1/btc/test3/txs/send',tmptx)).data
|
||||||
|
// return res
|
||||||
|
// } catch (error) {
|
||||||
|
// return error.response.data
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
|
||||||
|
async getBalance(){
|
||||||
|
return await BTC.getBalance(this.address)
|
||||||
|
}
|
||||||
|
async getActions(){
|
||||||
|
return await BTC.getActions(this.address)
|
||||||
|
}
|
||||||
|
encrypt(key){
|
||||||
|
return BTC.encrypt(this,key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
BTC
|
||||||
|
}
|
||||||
461
eth.js
Normal file
461
eth.js
Normal file
@ -0,0 +1,461 @@
|
|||||||
|
'use strict'
|
||||||
|
const eth = require('etherscan-api').init('E3ZFFAEMNN33KX4HHVUZ4KF8XY1FXMR4BI');
|
||||||
|
const secretStorage = require('./utils/secret-storage');
|
||||||
|
const SigningKey = require('./utils/signing-key.js');
|
||||||
|
const ticCommon = require('tic.common').Crypto;
|
||||||
|
const HDNode = require('./utils/hdnode');
|
||||||
|
const utils = require('./util.js');
|
||||||
|
const axios = require('axios');
|
||||||
|
|
||||||
|
require('setimmediate');
|
||||||
|
|
||||||
|
const GAS_UNIT_WEI = 1e18; //1wei
|
||||||
|
const GAS_UNIT_GWEI = 1e9; //1gwei = 1e9 wei
|
||||||
|
const GAS_Fee = 0.000021;
|
||||||
|
const GAS_Fee_ERC20 = 0.000060;
|
||||||
|
const GAS_LIMIT = 21000;
|
||||||
|
const GAS_LIMIT_ERC20 = 60000;
|
||||||
|
const defaultPath = "m/44'/60'/0'/0/0";
|
||||||
|
const ETH_NODE = require('./netConfig').ETH_NODE;
|
||||||
|
|
||||||
|
const transactionFields = [
|
||||||
|
{name: 'nonce', maxLength: 32, },
|
||||||
|
{name: 'gasPrice', maxLength: 32, },
|
||||||
|
{name: 'gasLimit', maxLength: 32, },
|
||||||
|
{name: 'to', length: 20, },
|
||||||
|
{name: 'value', maxLength: 32, },
|
||||||
|
{name: 'data'},
|
||||||
|
];
|
||||||
|
|
||||||
|
class ETH {
|
||||||
|
constructor(privateKey){
|
||||||
|
if(privateKey.length == 64 && !(privateKey.split('x')[1] && privateKey.split('x')[0] === '0'))
|
||||||
|
privateKey = '0x'+privateKey;
|
||||||
|
var signingKey = privateKey;
|
||||||
|
if (!(privateKey instanceof SigningKey)) {
|
||||||
|
signingKey = new SigningKey(privateKey);
|
||||||
|
}
|
||||||
|
Object.defineProperties(this, {
|
||||||
|
'privateKey' : {
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
value : signingKey.privateKey
|
||||||
|
},
|
||||||
|
'address' : {
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
value : signingKey.address,
|
||||||
|
},
|
||||||
|
'url' : {
|
||||||
|
enumerable: true,
|
||||||
|
get: function() { return this._url; },
|
||||||
|
set: function(url) {
|
||||||
|
if (typeof(url) !== 'string') { throw new Error('invalid url'); }
|
||||||
|
this._url = url;
|
||||||
|
},
|
||||||
|
},
|
||||||
|
'defaultGasFee' : {
|
||||||
|
enumerable: true,
|
||||||
|
get: function() { return this._defaultGasFee; },
|
||||||
|
set: function(value) {
|
||||||
|
if (typeof(value) !== 'number') { throw new Error('invalid defaultGasFee'); }
|
||||||
|
this._defaultGasFee = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})
|
||||||
|
this._defaultGasFee = GAS_Fee;
|
||||||
|
this._url = ETH_NODE;
|
||||||
|
}
|
||||||
|
static generateNewAccount(option = {path:defaultPath}){
|
||||||
|
//major path as default path >/0'/0/0
|
||||||
|
var mnemonic = ticCommon.randomSecword();
|
||||||
|
return Object.assign(ETH.fromMnemonic(mnemonic, option),{mnemonic,mnemonic})
|
||||||
|
}
|
||||||
|
static fromMnemonic(mnemonic, option = {path:defaultPath}){
|
||||||
|
HDNode.isValidMnemonic(mnemonic) //check valid mnemonic,will throw Error if not valid
|
||||||
|
let seed = HDNode.mnemonicToSeed(mnemonic)
|
||||||
|
return new ETH(HDNode.fromSeed(seed).derivePath(option.path).privateKey)
|
||||||
|
}
|
||||||
|
static async getBalance(address){
|
||||||
|
if(!address){ throw new Error('Address is required'); }
|
||||||
|
let res = (await axios.post(ETH_NODE,{
|
||||||
|
"jsonrpc":"2.0","method":"eth_getBalance","params":[address, "latest"],"id":1
|
||||||
|
})).data
|
||||||
|
if(res)
|
||||||
|
return parseInt(res.result)/1e18 //1000000000000000000
|
||||||
|
else return null
|
||||||
|
}
|
||||||
|
static async getActions(address){
|
||||||
|
let tx = await eth.account.txlist(address, 0 ,'latast')
|
||||||
|
if(tx && tx.message === "OK")
|
||||||
|
return tx.result
|
||||||
|
else return []
|
||||||
|
}
|
||||||
|
static fromEncryptedWallet(json, password, progressCallback) {
|
||||||
|
if (progressCallback && typeof(progressCallback) !== 'function') {
|
||||||
|
throw new Error('invalid callback');
|
||||||
|
}
|
||||||
|
|
||||||
|
return new Promise(function(resolve, reject) {
|
||||||
|
|
||||||
|
if (secretStorage.isCrowdsaleWallet(json)) {
|
||||||
|
try {
|
||||||
|
var privateKey = secretStorage.decryptCrowdsale(json, password);
|
||||||
|
resolve(new ETH(privateKey));
|
||||||
|
} catch (error) {
|
||||||
|
reject(error);
|
||||||
|
}
|
||||||
|
|
||||||
|
} else if (secretStorage.isValidWallet(json)) {
|
||||||
|
|
||||||
|
secretStorage.decrypt(json, password, progressCallback).then(function(signingKey) {
|
||||||
|
var wallet = new ETH(signingKey);
|
||||||
|
if (signingKey.mnemonic && signingKey.path) {
|
||||||
|
utils.defineProperty(wallet, 'mnemonic', signingKey.mnemonic);
|
||||||
|
utils.defineProperty(wallet, 'path', signingKey.path);
|
||||||
|
}
|
||||||
|
resolve(wallet);
|
||||||
|
return null;
|
||||||
|
}, function(error) {
|
||||||
|
reject(error);
|
||||||
|
}).catch(function(error) { reject(error); });
|
||||||
|
|
||||||
|
} else {
|
||||||
|
reject('invalid wallet JSON');
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
static parseTransaction(rawTransaction){
|
||||||
|
rawTransaction = utils.hexlify(rawTransaction, 'rawTransaction');
|
||||||
|
var signedTransaction = utils.RLP.decode(rawTransaction);
|
||||||
|
if (signedTransaction.length !== 9) { throw new Error('invalid transaction'); }
|
||||||
|
|
||||||
|
var raw = [];
|
||||||
|
|
||||||
|
var transaction = {};
|
||||||
|
transactionFields.forEach(function(fieldInfo, index) {
|
||||||
|
transaction[fieldInfo.name] = signedTransaction[index];
|
||||||
|
raw.push(signedTransaction[index]);
|
||||||
|
});
|
||||||
|
|
||||||
|
if (transaction.to) {
|
||||||
|
if (transaction.to == '0x') {
|
||||||
|
delete transaction.to;
|
||||||
|
} else {
|
||||||
|
transaction.to = utils.getAddress(transaction.to);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
['gasPrice', 'gasLimit', 'nonce', 'value'].forEach(function(name) {
|
||||||
|
if (!transaction[name]) { return; }
|
||||||
|
if (transaction[name].length === 0) {
|
||||||
|
transaction[name] = utils.bigNumberify(0);
|
||||||
|
} else {
|
||||||
|
transaction[name] = utils.bigNumberify(transaction[name]);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
if (transaction.nonce) {
|
||||||
|
transaction.nonce = transaction.nonce.toNumber();
|
||||||
|
} else {
|
||||||
|
transaction.nonce = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
var v = utils.arrayify(signedTransaction[6]);
|
||||||
|
var r = utils.arrayify(signedTransaction[7]);
|
||||||
|
var s = utils.arrayify(signedTransaction[8]);
|
||||||
|
|
||||||
|
if (v.length >= 1 && r.length >= 1 && r.length <= 32 && s.length >= 1 && s.length <= 32) {
|
||||||
|
transaction.v = utils.bigNumberify(v).toNumber();
|
||||||
|
transaction.r = signedTransaction[7];
|
||||||
|
transaction.s = signedTransaction[8];
|
||||||
|
|
||||||
|
var chainId = (transaction.v - 35) / 2;
|
||||||
|
if (chainId < 0) { chainId = 0; }
|
||||||
|
chainId = parseInt(chainId);
|
||||||
|
|
||||||
|
transaction.chainId = chainId;
|
||||||
|
|
||||||
|
var recoveryParam = transaction.v - 27;
|
||||||
|
|
||||||
|
if (chainId) {
|
||||||
|
raw.push(utils.hexlify(chainId));
|
||||||
|
raw.push('0x');
|
||||||
|
raw.push('0x');
|
||||||
|
recoveryParam -= chainId * 2 + 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
var digest = utils.keccak256(utils.RLP.encode(raw));
|
||||||
|
try {
|
||||||
|
transaction.from = SigningKey.recover(digest, r, s, recoveryParam);
|
||||||
|
} catch (error) {
|
||||||
|
console.log(error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return transaction;
|
||||||
|
}
|
||||||
|
static encrypt(data, key){
|
||||||
|
if(!data || !key) throw new Error('Required Params Missing')
|
||||||
|
return ticCommon.encrypt(data,key)
|
||||||
|
}
|
||||||
|
static decrypt(data, key){
|
||||||
|
return ticCommon.decrypt(data, key, {format:"json"}) //return null for wrong key
|
||||||
|
}
|
||||||
|
static async estimateGasPrice(){
|
||||||
|
try{
|
||||||
|
return parseInt((await axios.post(ETH_NODE, {
|
||||||
|
"method": "eth_gasPrice",
|
||||||
|
"id": "6842",
|
||||||
|
"jsonrpc": "2.0"
|
||||||
|
})).data.result)/1e9
|
||||||
|
}
|
||||||
|
catch(err){
|
||||||
|
return 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static isValidAddress(address){
|
||||||
|
let res = address.match(/^(0x)?[0-9a-fA-F]{40}$/)
|
||||||
|
return res && res[0].slice(0,2) === '0x'
|
||||||
|
}
|
||||||
|
|
||||||
|
async getBalance(){
|
||||||
|
return ETH.getBalance(this.address)
|
||||||
|
}
|
||||||
|
async getActions(){
|
||||||
|
return ETH.getActions(this.address)
|
||||||
|
}
|
||||||
|
async getTransactionCount(){
|
||||||
|
if(!this._url){ throw new Error('Base url required'); }
|
||||||
|
var self = this;
|
||||||
|
return (await axios.post(this._url,{
|
||||||
|
"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[self.address, "latest"],"id":1
|
||||||
|
})).data.result||null
|
||||||
|
}
|
||||||
|
signTransaction(transaction){
|
||||||
|
var chainId = transaction.chainId;
|
||||||
|
if (chainId == null && this.provider) { chainId = this.provider.chainId; }
|
||||||
|
if (!chainId) { chainId = 0; }
|
||||||
|
|
||||||
|
var raw = [];
|
||||||
|
transactionFields.forEach(function(fieldInfo) {
|
||||||
|
var value = transaction[fieldInfo.name] || ([]);
|
||||||
|
value = utils.arrayify(utils.hexlify(value), fieldInfo.name);
|
||||||
|
|
||||||
|
// Fixed-width field
|
||||||
|
if (fieldInfo.length && value.length !== fieldInfo.length && value.length > 0) {
|
||||||
|
var error = new Error('invalid ' + fieldInfo.name);
|
||||||
|
error.reason = 'wrong length';
|
||||||
|
error.value = value;
|
||||||
|
throw error;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Variable-width (with a maximum)
|
||||||
|
if (fieldInfo.maxLength) {
|
||||||
|
value = utils.stripZeros(value);
|
||||||
|
if (value.length > fieldInfo.maxLength) {
|
||||||
|
var error = new Error('invalid ' + fieldInfo.name);
|
||||||
|
error.reason = 'too long';
|
||||||
|
error.value = value;
|
||||||
|
throw error;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
raw.push(utils.hexlify(value));
|
||||||
|
});
|
||||||
|
|
||||||
|
if (chainId) {
|
||||||
|
raw.push(utils.hexlify(chainId));
|
||||||
|
raw.push('0x');
|
||||||
|
raw.push('0x');
|
||||||
|
}
|
||||||
|
|
||||||
|
var digest = utils.keccak256(utils.RLP.encode(raw));
|
||||||
|
var signingKey = new SigningKey(this.privateKey);
|
||||||
|
var signature = signingKey.signDigest(digest);
|
||||||
|
|
||||||
|
var v = 27 + signature.recoveryParam
|
||||||
|
if (chainId) {
|
||||||
|
raw.pop();
|
||||||
|
raw.pop();
|
||||||
|
raw.pop();
|
||||||
|
v += chainId * 2 + 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
raw.push(utils.hexlify(v));
|
||||||
|
raw.push(utils.stripZeros(utils.arrayify(signature.r)));
|
||||||
|
raw.push(utils.stripZeros(utils.arrayify(signature.s)));
|
||||||
|
|
||||||
|
return utils.RLP.encode(raw);
|
||||||
|
}
|
||||||
|
async sendTransaction(toAddress, amount, option = {gasFee : GAS_Fee}){
|
||||||
|
/****************************************************************
|
||||||
|
1 Ether = 1e18 wei
|
||||||
|
1Gwei = 1e9 wei
|
||||||
|
*GWei as the unit of gasPrice, minimum gasPrice is 1Gwei
|
||||||
|
*unit of amount is ether，should be translate to wei
|
||||||
|
****************************************************************/
|
||||||
|
let nonce = await this.getTransactionCount();
|
||||||
|
if(!nonce) nonce = '0x0'
|
||||||
|
var gasPrice, gasLimit;
|
||||||
|
if(!option.gasPrice || !option.gasLimit){
|
||||||
|
//Normal Mode:use customized gasFee( ether ) to caculate gasPrice( wei ), gasLimit use default value
|
||||||
|
gasLimit = GAS_LIMIT;
|
||||||
|
gasPrice = String(option.gasFee * GAS_UNIT_WEI / gasLimit);
|
||||||
|
}
|
||||||
|
else{
|
||||||
|
//Advance Mode:specified the gasLimit and gasPrice( gwei )
|
||||||
|
gasLimit = option.gasLimit;
|
||||||
|
gasPrice = String(GAS_UNIT_GWEI * option.gasPrice)
|
||||||
|
}
|
||||||
|
let transaction = {
|
||||||
|
nonce: nonce,
|
||||||
|
gasLimit: gasLimit,
|
||||||
|
gasPrice: utils.bigNumberify(gasPrice),
|
||||||
|
to: toAddress,
|
||||||
|
|
||||||
|
value: utils.parseEther(String(amount)),
|
||||||
|
};
|
||||||
|
try{
|
||||||
|
let signedTransaction = this.signTransaction(transaction);
|
||||||
|
let ethTxRes = (await axios.post(ETH_NODE,{
|
||||||
|
"jsonrpc":"2.0",
|
||||||
|
"method":"eth_sendRawTransaction",
|
||||||
|
"params":[signedTransaction.toString('hex')],
|
||||||
|
"id":6842
|
||||||
|
})).data
|
||||||
|
if(ethTxRes && ethTxRes.result)
|
||||||
|
return ethTxRes
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
catch(err){
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
encrypt(key){
|
||||||
|
return ETH.encrypt(this, key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class ERC20 extends ETH{
|
||||||
|
constructor(privateKey, contractAddress){
|
||||||
|
if(!contractAddress) throw new Error('Missing contractAddress')
|
||||||
|
super(privateKey);
|
||||||
|
Object.defineProperty(this, 'contractAddress',{
|
||||||
|
enumerable:true,
|
||||||
|
writable:false,
|
||||||
|
value:contractAddress
|
||||||
|
})
|
||||||
|
}
|
||||||
|
static async getDecimals(contractAddress){
|
||||||
|
if(!contractAddress) throw new Error('Missing params')
|
||||||
|
let queryAddress = '0x313ce567' + (contractAddress.split('x')[1]).padStart(64,'0')
|
||||||
|
let params = [{"to":contractAddress, "data":queryAddress},"latest"]
|
||||||
|
let queryData = {
|
||||||
|
"jsonrpc":"2.0",
|
||||||
|
"method":"eth_call",
|
||||||
|
"params":params,
|
||||||
|
"id":6842
|
||||||
|
}
|
||||||
|
return parseInt((await axios.post(ETH_NODE, queryData)).data.result)
|
||||||
|
}
|
||||||
|
static async getBalance(address, contractAddress){
|
||||||
|
if(!address || !contractAddress) throw new Error('Missing params')
|
||||||
|
let queryAddress = '0x70a08231' + (address.split('x')[1]).padStart(64,'0')
|
||||||
|
let params = [{"to":contractAddress, "data":queryAddress},"latest"]
|
||||||
|
let queryData = {
|
||||||
|
"jsonrpc":"2.0",
|
||||||
|
"method":"eth_call",
|
||||||
|
"params":params,
|
||||||
|
"id":6842
|
||||||
|
}
|
||||||
|
// return parseInt(erc20res.result)/Number('10'.padEnd(ERC20Table[obj.name].decimals+1,'0'))
|
||||||
|
let res = (await axios.post(ETH_NODE, queryData)).data.result
|
||||||
|
if(res == '0x') return 0
|
||||||
|
return parseInt(res)
|
||||||
|
}
|
||||||
|
static async getActions(address, contractAddress){
|
||||||
|
try{
|
||||||
|
let res = (await eth.account.tokentx(address,contractAddress))
|
||||||
|
if(res && res.result)
|
||||||
|
return res.result
|
||||||
|
}
|
||||||
|
catch(err){
|
||||||
|
return []
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
async getBalance(){
|
||||||
|
return ERC20.getBalance(this.address, this.contractAddress)
|
||||||
|
}
|
||||||
|
async getActions(){
|
||||||
|
return ERC20.getActions(this.address, this.contractAddress)
|
||||||
|
}
|
||||||
|
async getDecimals(){
|
||||||
|
let decimals = await ERC20.getDecimals(this.contractAddress)
|
||||||
|
if(decimals)
|
||||||
|
Object.defineProperty(this, 'decimals', {
|
||||||
|
enumerable:true,
|
||||||
|
value:decimals,
|
||||||
|
writable:false
|
||||||
|
})
|
||||||
|
else
|
||||||
|
return 0 // any good idea?
|
||||||
|
}
|
||||||
|
async sendTransaction(toAddress, amount, option = {gasFee : GAS_Fee_ERC20}){
|
||||||
|
/****************************************************************
|
||||||
|
1 Ether = 1e18 wei
|
||||||
|
1 Gwei = 1e9 wei
|
||||||
|
*GWei as the unit of gasPrice, minimum gasPrice is 1Gwei
|
||||||
|
minimum gaslimit for erc20transaction is 60000
|
||||||
|
****************************************************************/
|
||||||
|
var nonce = await this.getTransactionCount();
|
||||||
|
var gasPrice, gasLimit, decimals, contractAddress = this.contractAddress;
|
||||||
|
if(!nonce) nonce = '0x0'
|
||||||
|
if(!option.gasPrice || !option.gasLimit){
|
||||||
|
//Normal Mode:use customized gasFee( ether ) to caculate gasPrice( wei ), gasLimit use default value
|
||||||
|
gasLimit = GAS_LIMIT_ERC20;
|
||||||
|
gasPrice = String(option.gasFee * GAS_UNIT_WEI / gasLimit);
|
||||||
|
}
|
||||||
|
else{
|
||||||
|
//Advance Mode:specified the gasLimit and gasPrice( gwei )
|
||||||
|
gasLimit = option.gasLimit;
|
||||||
|
gasPrice = String(GAS_UNIT_GWEI * option.gasPrice)
|
||||||
|
}
|
||||||
|
if(!option.decimals) decimals = await ERC20.getDecimals(contractAddress)
|
||||||
|
let txBody = '0x' + 'a9059cbb' + toAddress.split('x')[1].padStart(64,'0')+ Number(amount*Math.pow(10,decimals)).toString(16).padStart(64,'0')
|
||||||
|
let transaction = {
|
||||||
|
nonce: nonce,
|
||||||
|
gasLimit: gasLimit,
|
||||||
|
gasPrice : utils.bigNumberify(gasPrice),
|
||||||
|
to: contractAddress,
|
||||||
|
value : 0,
|
||||||
|
data : txBody
|
||||||
|
};
|
||||||
|
let signedTransaction = this.signTransaction(transaction);
|
||||||
|
try{
|
||||||
|
let erc20TxRes = (await axios.post(ETH_NODE, {
|
||||||
|
"jsonrpc":"2.0",
|
||||||
|
"method":"eth_sendRawTransaction",
|
||||||
|
"params":[signedTransaction.toString('hex')],
|
||||||
|
"id":6842
|
||||||
|
})).data
|
||||||
|
if(erc20TxRes && erc20TxRes.result)
|
||||||
|
return erc20TxRes.result
|
||||||
|
console.log(erc20TxRes)
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
catch(err){
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
ETH, ERC20
|
||||||
|
}
|
||||||
|
|
||||||
16
index.js
Normal file
16
index.js
Normal file
@ -0,0 +1,16 @@
|
|||||||
|
'use strict'
|
||||||
|
|
||||||
|
const TIC = require('./tic.js').TIC;
|
||||||
|
const ETH = require('./eth.js').ETH;
|
||||||
|
const ERC20 = require('./eth.js').ERC20;
|
||||||
|
const BTC = require('./btc.js').BTC;
|
||||||
|
const Account = require('./Account').Account;
|
||||||
|
const Crypto = require('tic.common').Crypto;
|
||||||
|
module.exports = {
|
||||||
|
TIC,
|
||||||
|
ETH,
|
||||||
|
BTC,
|
||||||
|
ERC20,
|
||||||
|
Account,
|
||||||
|
Crypto,
|
||||||
|
}
|
||||||
14
netConfig.js
Normal file
14
netConfig.js
Normal file
@ -0,0 +1,14 @@
|
|||||||
|
|
||||||
|
const TIC_NODE = 'https://bank.bittic.net:7285/api';
|
||||||
|
const BTC_NODE = 'https://api.blockcypher.com/v1/btc/main';
|
||||||
|
const BTC_NODE2 = 'https://blockchain.info'//https://blockchain.info/unspent?active=12HnmPpLomtPL53Q4s6xEqRB4wkMHi5GEZ
|
||||||
|
const ETH_NODE = 'https://mainnet.infura.io/8284219b092f4cc69f3de29e532b1eb2';
|
||||||
|
const ETH_NODE2 = 'https://api.myetherapi.com/eth';
|
||||||
|
const ETH_TEST_NODE = 'https://ropsten.infura.io/8284219b092f4cc69f3de29e532b1eb2';
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
TIC_NODE,
|
||||||
|
ETH_NODE,
|
||||||
|
BTC_NODE,
|
||||||
|
BTC_NODE2,
|
||||||
|
}
|
||||||
24
package.json
Normal file
24
package.json
Normal file
@ -0,0 +1,24 @@
|
|||||||
|
{
|
||||||
|
"name": "tic.common",
|
||||||
|
"version": "1.2.1",
|
||||||
|
"dependencies": {
|
||||||
|
"aes-js": "^3.1.1",
|
||||||
|
"axios": "^0.18.0",
|
||||||
|
"bitcoinjs-lib": "^4.0.2",
|
||||||
|
"elliptic": "^6.4.1",
|
||||||
|
"etherscan-api": "^8.1.3",
|
||||||
|
"js-sha3": "^0.8.0",
|
||||||
|
"scrypt-js": "^2.0.3",
|
||||||
|
"setimmediate": "^1.0.5",
|
||||||
|
"tic.common": "git+https://git.faronear.org/tic/tic.common.git",
|
||||||
|
"uuid": "^3.3.2"
|
||||||
|
},
|
||||||
|
"deprecated": false,
|
||||||
|
"description": "blockchain tool for ticwallet",
|
||||||
|
"keywords": [
|
||||||
|
"tool",
|
||||||
|
"blockchain",
|
||||||
|
"tic"
|
||||||
|
],
|
||||||
|
"main": "index.js"
|
||||||
|
}
|
||||||
136
tic.js
Normal file
136
tic.js
Normal file
@ -0,0 +1,136 @@
|
|||||||
|
'use strict'
|
||||||
|
const axios = require('axios')
|
||||||
|
const ticCommon = require('tic.common').Crypto
|
||||||
|
const ticActTransfer = require('tic.common').ActTransfer
|
||||||
|
|
||||||
|
const TIC_TXFEE = 10;
|
||||||
|
const TIC_NODE = require('./netConfig').TIC_NODE
|
||||||
|
|
||||||
|
class TIC {
|
||||||
|
constructor(seckey,option={}){
|
||||||
|
if(!seckey||!ticCommon.isSeckey(seckey)) throw "ERROR:Invalid Seckey"
|
||||||
|
Object.defineProperties(this, {
|
||||||
|
'seckey' : {
|
||||||
|
value : seckey,
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
},
|
||||||
|
'pubkey' : {
|
||||||
|
value : ticCommon.seckey2pubkey(seckey),
|
||||||
|
enumerable : true,
|
||||||
|
writable : false,
|
||||||
|
},
|
||||||
|
'address' : {
|
||||||
|
value : ticCommon.pubkey2address(ticCommon.seckey2pubkey(seckey)),
|
||||||
|
enumerable : true,
|
||||||
|
writable : false
|
||||||
|
}
|
||||||
|
})
|
||||||
|
Object.assign(this,{
|
||||||
|
_url : option._url||TIC_NODE,
|
||||||
|
_defaultFee : option.fee||TIC_TXFEE //fee cannot be zero
|
||||||
|
})
|
||||||
|
}
|
||||||
|
get url(){return this._url}
|
||||||
|
set url(newURL){this._url = newURL}
|
||||||
|
get txfee(){return this._defaultFee}
|
||||||
|
set txfee(fee){this._defaultFee = fee}
|
||||||
|
|
||||||
|
static generateNewAccount(){
|
||||||
|
var secword = ticCommon.randomSecword()
|
||||||
|
return Object.assign(new TIC(ticCommon.secword2keypair(secword).seckey),{secword:secword})
|
||||||
|
}
|
||||||
|
static fromMnemonic(secword){
|
||||||
|
if(!secword||!ticCommon.isSecword(secword)) throw "ERROR:Invalid Secword"
|
||||||
|
return new TIC(ticCommon.secword2keypair(secword).seckey)
|
||||||
|
}
|
||||||
|
static async getBalance(address){
|
||||||
|
if(!address){ throw new Error('Address is required'); }
|
||||||
|
return (await axios.post(TIC_NODE+'/Account/getBalance',{
|
||||||
|
"Account" : {
|
||||||
|
"address":address
|
||||||
|
}
|
||||||
|
})).data
|
||||||
|
}
|
||||||
|
static async getActions(address){
|
||||||
|
if(!address){ throw new Error('Address is required'); }
|
||||||
|
return (await axios.post(TIC_NODE+'/Action/getActionList',{
|
||||||
|
"Action" : {
|
||||||
|
"actorAddress" : address,
|
||||||
|
"toAddress" : address
|
||||||
|
},
|
||||||
|
"config":{
|
||||||
|
"logic":"OR"
|
||||||
|
}
|
||||||
|
})).data
|
||||||
|
}
|
||||||
|
static encrypt(data, key){
|
||||||
|
if(!data || !key) throw new Error('Required Params Missing')
|
||||||
|
return ticCommon.encrypt(data,key)
|
||||||
|
}
|
||||||
|
static decrypt(data, key){
|
||||||
|
return ticCommon.decrypt(data, key, {format:"json"}) //return null for wrong key
|
||||||
|
}
|
||||||
|
|
||||||
|
static isValidAddress(address){
|
||||||
|
return ticCommon.isAddress(address)
|
||||||
|
}
|
||||||
|
|
||||||
|
async sendTransaction(toAddress, amount, option = {gasFee : TIC_TXFEE}){
|
||||||
|
if(!toAddress||!amount){throw new Error("ERROR:RequiredParamsMissing")} //amount cannot be zero
|
||||||
|
let action = new ticActTransfer({
|
||||||
|
amount: parseInt(amount),
|
||||||
|
toAddress: toAddress,
|
||||||
|
fee: option.gasFee
|
||||||
|
})
|
||||||
|
//对交易数据签名,packMe 内的参数是交易发起人的keypair
|
||||||
|
action.packMe({
|
||||||
|
seckey: this.seckey,
|
||||||
|
pubkey: this.pubkey,
|
||||||
|
address: this.address
|
||||||
|
})
|
||||||
|
let data = {
|
||||||
|
Action:action
|
||||||
|
}
|
||||||
|
try{
|
||||||
|
|
||||||
|
let res = (await axios.post(this._url + '/Action/prepare',data)).data
|
||||||
|
return res
|
||||||
|
}catch(err){
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
async getBalance(){
|
||||||
|
return TIC.getBalance(this.address)
|
||||||
|
}
|
||||||
|
async getActions(){
|
||||||
|
return TIC.getActions(this.address)
|
||||||
|
}
|
||||||
|
getSerializedTx(option){
|
||||||
|
if(!option.toAddress||!option.amount){throw new Error("ERROR:RequiredParamsMissing")}
|
||||||
|
let action=new ticActTransfer({
|
||||||
|
amount: parseInt(option.amount),
|
||||||
|
toAddress: option.toAddress,
|
||||||
|
fee:option.fee||this._defaultFee
|
||||||
|
})
|
||||||
|
//sign for txBody use function packMe, which needs actor's keypair as parameter
|
||||||
|
action.packMe({
|
||||||
|
seckey: this.seckey,
|
||||||
|
pubkey: this.pubkey,
|
||||||
|
address: this.address
|
||||||
|
})
|
||||||
|
return action
|
||||||
|
}
|
||||||
|
//default key for sign&encrypt is account's seckey,other keys are optional.
|
||||||
|
sign(message,key = this.seckey){
|
||||||
|
return ticCommon.sign(message,key)
|
||||||
|
}
|
||||||
|
verify(message,signature){
|
||||||
|
return ticCommon.sign(message,signature,this.seckey)
|
||||||
|
}
|
||||||
|
encrypt(key){
|
||||||
|
return TIC.encrypt(this, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
module.exports = {TIC}
|
||||||
35
util.js
Normal file
35
util.js
Normal file
@ -0,0 +1,35 @@
|
|||||||
|
'use strict'
|
||||||
|
module.exports = (function() {
|
||||||
|
var convert = require('./utils/convert');
|
||||||
|
var hmac = require('./utils/hmac');
|
||||||
|
var base64 = require('./utils/base64');
|
||||||
|
return {
|
||||||
|
defineProperty: require('./utils/properties').defineProperty,
|
||||||
|
|
||||||
|
arrayify: convert.arrayify,
|
||||||
|
hexlify: convert.hexlify,
|
||||||
|
stripZeros: convert.stripZeros,
|
||||||
|
concat: convert.concat,
|
||||||
|
padZeros: convert.padZeros,
|
||||||
|
stripZeros: convert.stripZeros,
|
||||||
|
base64: base64,
|
||||||
|
|
||||||
|
bigNumberify: require('./utils/bignumber').bigNumberify,
|
||||||
|
|
||||||
|
toUtf8Bytes: require('./utils/utf8').toUtf8Bytes,
|
||||||
|
|
||||||
|
getAddress: require('./utils/address').getAddress,
|
||||||
|
|
||||||
|
keccak256: require('./utils/keccak256'),
|
||||||
|
|
||||||
|
RLP: require('./utils/rlp'),
|
||||||
|
|
||||||
|
pbkdf2: require('./utils/pbkdf2.js'),
|
||||||
|
|
||||||
|
createSha512Hmac: hmac.createSha512Hmac,
|
||||||
|
|
||||||
|
// isMnemonic: isMnemonic,
|
||||||
|
|
||||||
|
parseEther:require('./utils/units').parseEther
|
||||||
|
};
|
||||||
|
})();
|
||||||
1018
utils/abi-coder.js
Normal file
1018
utils/abi-coder.js
Normal file
File diff suppressed because it is too large
Load Diff
124
utils/address.js
Normal file
124
utils/address.js
Normal file
@ -0,0 +1,124 @@
|
|||||||
|
|
||||||
|
var BN = require('bn.js');
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
var throwError = require('./throw-error');
|
||||||
|
var keccak256 = require('./keccak256');
|
||||||
|
|
||||||
|
function getChecksumAddress(address) {
|
||||||
|
if (typeof(address) !== 'string' || !address.match(/^0x[0-9A-Fa-f]{40}$/)) {
|
||||||
|
throwError('invalid address', {input: address});
|
||||||
|
}
|
||||||
|
|
||||||
|
address = address.toLowerCase();
|
||||||
|
|
||||||
|
var hashed = address.substring(2).split('');
|
||||||
|
for (var i = 0; i < hashed.length; i++) {
|
||||||
|
hashed[i] = hashed[i].charCodeAt(0);
|
||||||
|
}
|
||||||
|
hashed = convert.arrayify(keccak256(hashed));
|
||||||
|
|
||||||
|
address = address.substring(2).split('');
|
||||||
|
for (var i = 0; i < 40; i += 2) {
|
||||||
|
if ((hashed[i >> 1] >> 4) >= 8) {
|
||||||
|
address[i] = address[i].toUpperCase();
|
||||||
|
}
|
||||||
|
if ((hashed[i >> 1] & 0x0f) >= 8) {
|
||||||
|
address[i + 1] = address[i + 1].toUpperCase();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return '0x' + address.join('');
|
||||||
|
}
|
||||||
|
|
||||||
|
// Shims for environments that are missing some required constants and functions
|
||||||
|
var MAX_SAFE_INTEGER = 0x1fffffffffffff;
|
||||||
|
|
||||||
|
function log10(x) {
|
||||||
|
if (Math.log10) { return Math.log10(x); }
|
||||||
|
return Math.log(x) / Math.LN10;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number
|
||||||
|
var ibanChecksum = (function() {
|
||||||
|
|
||||||
|
// Create lookup table
|
||||||
|
var ibanLookup = {};
|
||||||
|
for (var i = 0; i < 10; i++) { ibanLookup[String(i)] = String(i); }
|
||||||
|
for (var i = 0; i < 26; i++) { ibanLookup[String.fromCharCode(65 + i)] = String(10 + i); }
|
||||||
|
|
||||||
|
// How many decimal digits can we process? (for 64-bit float, this is 15)
|
||||||
|
var safeDigits = Math.floor(log10(MAX_SAFE_INTEGER));
|
||||||
|
|
||||||
|
return function(address) {
|
||||||
|
address = address.toUpperCase();
|
||||||
|
address = address.substring(4) + address.substring(0, 2) + '00';
|
||||||
|
|
||||||
|
var expanded = address.split('');
|
||||||
|
for (var i = 0; i < expanded.length; i++) {
|
||||||
|
expanded[i] = ibanLookup[expanded[i]];
|
||||||
|
}
|
||||||
|
expanded = expanded.join('');
|
||||||
|
|
||||||
|
// Javascript can handle integers safely up to 15 (decimal) digits
|
||||||
|
while (expanded.length >= safeDigits){
|
||||||
|
var block = expanded.substring(0, safeDigits);
|
||||||
|
expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
|
||||||
|
}
|
||||||
|
|
||||||
|
var checksum = String(98 - (parseInt(expanded, 10) % 97));
|
||||||
|
while (checksum.length < 2) { checksum = '0' + checksum; }
|
||||||
|
|
||||||
|
return checksum;
|
||||||
|
};
|
||||||
|
})();
|
||||||
|
|
||||||
|
function getAddress(address, icapFormat) {
|
||||||
|
var result = null;
|
||||||
|
|
||||||
|
if (typeof(address) !== 'string') {
|
||||||
|
throwError('invalid address', {input: address});
|
||||||
|
}
|
||||||
|
|
||||||
|
if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
|
||||||
|
|
||||||
|
// Missing the 0x prefix
|
||||||
|
if (address.substring(0, 2) !== '0x') { address = '0x' + address; }
|
||||||
|
|
||||||
|
result = getChecksumAddress(address);
|
||||||
|
|
||||||
|
// It is a checksummed address with a bad checksum
|
||||||
|
if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) {
|
||||||
|
throwError('invalid address checksum', { input: address, expected: result });
|
||||||
|
}
|
||||||
|
|
||||||
|
// Maybe ICAP? (we only support direct mode)
|
||||||
|
} else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
|
||||||
|
|
||||||
|
// It is an ICAP address with a bad checksum
|
||||||
|
if (address.substring(2, 4) !== ibanChecksum(address)) {
|
||||||
|
throwError('invalid address icap checksum', { input: address });
|
||||||
|
}
|
||||||
|
|
||||||
|
result = (new BN(address.substring(4), 36)).toString(16);
|
||||||
|
while (result.length < 40) { result = '0' + result; }
|
||||||
|
result = getChecksumAddress('0x' + result);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
throwError('invalid address', { input: address });
|
||||||
|
}
|
||||||
|
|
||||||
|
if (icapFormat) {
|
||||||
|
var base36 = (new BN(result.substring(2), 16)).toString(36).toUpperCase();
|
||||||
|
while (base36.length < 30) { base36 = '0' + base36; }
|
||||||
|
return 'XE' + ibanChecksum('XE00' + base36) + base36;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
getAddress: getAddress,
|
||||||
|
}
|
||||||
13
utils/base64.js
Normal file
13
utils/base64.js
Normal file
@ -0,0 +1,13 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
decode: function(textData) {
|
||||||
|
return convert.arrayify(new Buffer(textData, 'base64'));
|
||||||
|
},
|
||||||
|
|
||||||
|
encode: function(data) {
|
||||||
|
return (new Buffer(convert.arrayify(data))).toString('base64');
|
||||||
|
}
|
||||||
|
};
|
||||||
149
utils/bignumber.js
Normal file
149
utils/bignumber.js
Normal file
@ -0,0 +1,149 @@
|
|||||||
|
/**
|
||||||
|
* BigNumber
|
||||||
|
*
|
||||||
|
* A wrapper around the BN.js object. In the future we can swap out
|
||||||
|
* the underlying BN.js library for something smaller.
|
||||||
|
*/
|
||||||
|
|
||||||
|
var BN = require('bn.js');
|
||||||
|
|
||||||
|
var defineProperty = require('./properties').defineProperty;
|
||||||
|
var convert = require('./convert');
|
||||||
|
var throwError = require('./throw-error');
|
||||||
|
|
||||||
|
function BigNumber(value) {
|
||||||
|
if (!(this instanceof BigNumber)) { throw new Error('missing new'); }
|
||||||
|
|
||||||
|
if (convert.isHexString(value)) {
|
||||||
|
if (value == '0x') { value = '0x0'; }
|
||||||
|
value = new BN(value.substring(2), 16);
|
||||||
|
} else if (typeof(value) === 'string' && value[0] === '-' && convert.isHexString(value.substring(1))) {
|
||||||
|
value = (new BN(value.substring(3), 16)).mul(BigNumber.constantNegativeOne._bn);
|
||||||
|
|
||||||
|
} else if (typeof(value) === 'string' && value.match(/^-?[0-9]*$/)) {
|
||||||
|
if (value == '') { value = '0'; }
|
||||||
|
value = new BN(value);
|
||||||
|
|
||||||
|
} else if (typeof(value) === 'number' && parseInt(value) == value) {
|
||||||
|
value = new BN(value);
|
||||||
|
|
||||||
|
} else if (BN.isBN(value)) {
|
||||||
|
//value = value
|
||||||
|
|
||||||
|
} else if (isBigNumber(value)) {
|
||||||
|
value = value._bn;
|
||||||
|
|
||||||
|
} else if (convert.isArrayish(value)) {
|
||||||
|
value = new BN(convert.hexlify(value).substring(2), 16);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
throwError('invalid BigNumber value', { input: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
defineProperty(this, '_bn', value);
|
||||||
|
}
|
||||||
|
|
||||||
|
defineProperty(BigNumber, 'constantNegativeOne', bigNumberify(-1));
|
||||||
|
defineProperty(BigNumber, 'constantZero', bigNumberify(0));
|
||||||
|
defineProperty(BigNumber, 'constantOne', bigNumberify(1));
|
||||||
|
defineProperty(BigNumber, 'constantTwo', bigNumberify(2));
|
||||||
|
defineProperty(BigNumber, 'constantWeiPerEther', bigNumberify(new BN('1000000000000000000')));
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'fromTwos', function(value) {
|
||||||
|
return new BigNumber(this._bn.fromTwos(value));
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'toTwos', function(value) {
|
||||||
|
return new BigNumber(this._bn.toTwos(value));
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'add', function(other) {
|
||||||
|
return new BigNumber(this._bn.add(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'sub', function(other) {
|
||||||
|
return new BigNumber(this._bn.sub(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'div', function(other) {
|
||||||
|
return new BigNumber(this._bn.div(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'mul', function(other) {
|
||||||
|
return new BigNumber(this._bn.mul(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'mod', function(other) {
|
||||||
|
return new BigNumber(this._bn.mod(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'pow', function(other) {
|
||||||
|
return new BigNumber(this._bn.pow(bigNumberify(other)._bn));
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'maskn', function(value) {
|
||||||
|
return new BigNumber(this._bn.maskn(value));
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'eq', function(other) {
|
||||||
|
return this._bn.eq(bigNumberify(other)._bn);
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'lt', function(other) {
|
||||||
|
return this._bn.lt(bigNumberify(other)._bn);
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'lte', function(other) {
|
||||||
|
return this._bn.lte(bigNumberify(other)._bn);
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'gt', function(other) {
|
||||||
|
return this._bn.gt(bigNumberify(other)._bn);
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'gte', function(other) {
|
||||||
|
return this._bn.gte(bigNumberify(other)._bn);
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'isZero', function() {
|
||||||
|
return this._bn.isZero();
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'toNumber', function(base) {
|
||||||
|
return this._bn.toNumber();
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'toString', function() {
|
||||||
|
//return this._bn.toString(base || 10);
|
||||||
|
return this._bn.toString(10);
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(BigNumber.prototype, 'toHexString', function() {
|
||||||
|
var hex = this._bn.toString(16);
|
||||||
|
if (hex.length % 2) { hex = '0' + hex; }
|
||||||
|
return '0x' + hex;
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
function isBigNumber(value) {
|
||||||
|
return (value._bn && value._bn.mod);
|
||||||
|
}
|
||||||
|
|
||||||
|
function bigNumberify(value) {
|
||||||
|
if (isBigNumber(value)) { return value; }
|
||||||
|
return new BigNumber(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
isBigNumber: isBigNumber,
|
||||||
|
bigNumberify: bigNumberify,
|
||||||
|
BigNumber: BigNumber
|
||||||
|
};
|
||||||
24
utils/browser-base64.js
Normal file
24
utils/browser-base64.js
Normal file
@ -0,0 +1,24 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
decode: function(textData) {
|
||||||
|
textData = atob(textData);
|
||||||
|
var data = [];
|
||||||
|
for (var i = 0; i < textData.length; i++) {
|
||||||
|
data.push(textData.charCodeAt(i));
|
||||||
|
}
|
||||||
|
return convert.arrayify(data);
|
||||||
|
},
|
||||||
|
encode: function(data) {
|
||||||
|
data = convert.arrayify(data);
|
||||||
|
var textData = '';
|
||||||
|
for (var i = 0; i < data.length; i++) {
|
||||||
|
textData += String.fromCharCode(data[i]);
|
||||||
|
}
|
||||||
|
return btoa(textData);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
43
utils/browser-random-bytes.js
Normal file
43
utils/browser-random-bytes.js
Normal file
@ -0,0 +1,43 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
var defineProperty = require('./properties').defineProperty;
|
||||||
|
|
||||||
|
var crypto = global.crypto || global.msCrypto;
|
||||||
|
if (!crypto || !crypto.getRandomValues) {
|
||||||
|
|
||||||
|
console.log('WARNING: Missing strong random number source; using weak randomBytes');
|
||||||
|
|
||||||
|
crypto = {
|
||||||
|
getRandomValues: function(buffer) {
|
||||||
|
for (var round = 0; round < 20; round++) {
|
||||||
|
for (var i = 0; i < buffer.length; i++) {
|
||||||
|
if (round) {
|
||||||
|
buffer[i] ^= parseInt(256 * Math.random());
|
||||||
|
} else {
|
||||||
|
buffer[i] = parseInt(256 * Math.random());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return buffer;
|
||||||
|
},
|
||||||
|
_weakCrypto: true
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function randomBytes(length) {
|
||||||
|
if (length <= 0 || length > 1024 || parseInt(length) != length) {
|
||||||
|
throw new Error('invalid length');
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = new Uint8Array(length);
|
||||||
|
crypto.getRandomValues(result);
|
||||||
|
return convert.arrayify(result);
|
||||||
|
};
|
||||||
|
|
||||||
|
if (crypto._weakCrypto === true) {
|
||||||
|
defineProperty(randomBytes, '_weakCrypto', true);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = randomBytes;
|
||||||
20
utils/contract-address.js
Normal file
20
utils/contract-address.js
Normal file
@ -0,0 +1,20 @@
|
|||||||
|
|
||||||
|
var getAddress = require('./address').getAddress;
|
||||||
|
var convert = require('./convert');
|
||||||
|
var keccak256 = require('./keccak256');
|
||||||
|
var RLP = require('./rlp');
|
||||||
|
|
||||||
|
// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed
|
||||||
|
function getContractAddress(transaction) {
|
||||||
|
if (!transaction.from) { throw new Error('missing from address'); }
|
||||||
|
var nonce = transaction.nonce;
|
||||||
|
|
||||||
|
return getAddress('0x' + keccak256(RLP.encode([
|
||||||
|
getAddress(transaction.from),
|
||||||
|
convert.stripZeros(convert.hexlify(nonce, 'nonce'))
|
||||||
|
])).substring(26));
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
getContractAddress: getContractAddress,
|
||||||
|
}
|
||||||
224
utils/convert.js
Normal file
224
utils/convert.js
Normal file
@ -0,0 +1,224 @@
|
|||||||
|
/**
|
||||||
|
* Conversion Utilities
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
var defineProperty = require('./properties.js').defineProperty;
|
||||||
|
|
||||||
|
var errors = require('./errors');
|
||||||
|
|
||||||
|
function addSlice(array) {
|
||||||
|
if (array.slice) { return array; }
|
||||||
|
|
||||||
|
array.slice = function() {
|
||||||
|
var args = Array.prototype.slice.call(arguments);
|
||||||
|
return new Uint8Array(Array.prototype.slice.apply(array, args));
|
||||||
|
}
|
||||||
|
|
||||||
|
return array;
|
||||||
|
}
|
||||||
|
|
||||||
|
function isArrayish(value) {
|
||||||
|
if (!value || parseInt(value.length) != value.length || typeof(value) === 'string') {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var i = 0; i < value.length; i++) {
|
||||||
|
var v = value[i];
|
||||||
|
if (v < 0 || v >= 256 || parseInt(v) != v) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
function arrayify(value) {
|
||||||
|
if (value == null) {
|
||||||
|
errors.throwError('cannot convert null value to array', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
if (value && value.toHexString) {
|
||||||
|
value = value.toHexString();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isHexString(value)) {
|
||||||
|
value = value.substring(2);
|
||||||
|
if (value.length % 2) { value = '0' + value; }
|
||||||
|
|
||||||
|
var result = [];
|
||||||
|
for (var i = 0; i < value.length; i += 2) {
|
||||||
|
result.push(parseInt(value.substr(i, 2), 16));
|
||||||
|
}
|
||||||
|
|
||||||
|
return addSlice(new Uint8Array(result));
|
||||||
|
|
||||||
|
} else if (typeof(value) === 'string') {
|
||||||
|
if (value.match(/^[0-9a-fA-F]*$/)) {
|
||||||
|
errors.throwError('hex string must have 0x prefix', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
||||||
|
}
|
||||||
|
errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isArrayish(value)) {
|
||||||
|
return addSlice(new Uint8Array(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
errors.throwError('invalid arrayify value', { arg: 'value', value: value, type: typeof(value) });
|
||||||
|
}
|
||||||
|
|
||||||
|
function concat(objects) {
|
||||||
|
var arrays = [];
|
||||||
|
var length = 0;
|
||||||
|
for (var i = 0; i < objects.length; i++) {
|
||||||
|
var object = arrayify(objects[i])
|
||||||
|
arrays.push(object);
|
||||||
|
length += object.length;
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = new Uint8Array(length);
|
||||||
|
var offset = 0;
|
||||||
|
for (var i = 0; i < arrays.length; i++) {
|
||||||
|
result.set(arrays[i], offset);
|
||||||
|
offset += arrays[i].length;
|
||||||
|
}
|
||||||
|
|
||||||
|
return addSlice(result);
|
||||||
|
}
|
||||||
|
function stripZeros(value) {
|
||||||
|
value = arrayify(value);
|
||||||
|
|
||||||
|
if (value.length === 0) { return value; }
|
||||||
|
|
||||||
|
// Find the first non-zero entry
|
||||||
|
var start = 0;
|
||||||
|
while (value[start] === 0) { start++ }
|
||||||
|
|
||||||
|
// If we started with zeros, strip them
|
||||||
|
if (start) {
|
||||||
|
value = value.slice(start);
|
||||||
|
}
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
function padZeros(value, length) {
|
||||||
|
value = arrayify(value);
|
||||||
|
|
||||||
|
if (length < value.length) { throw new Error('cannot pad'); }
|
||||||
|
|
||||||
|
var result = new Uint8Array(length);
|
||||||
|
result.set(value, length - value.length);
|
||||||
|
return addSlice(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
function isHexString(value, length) {
|
||||||
|
if (typeof(value) !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if (length && value.length !== 2 + 2 * length) { return false; }
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
var HexCharacters = '0123456789abcdef';
|
||||||
|
|
||||||
|
function hexlify(value) {
|
||||||
|
|
||||||
|
if (value && value.toHexString) {
|
||||||
|
return value.toHexString();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof(value) === 'number') {
|
||||||
|
if (value < 0) {
|
||||||
|
errors.throwError('cannot hexlify negative value', errors.INVALID_ARG, { arg: 'value', value: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
var hex = '';
|
||||||
|
while (value) {
|
||||||
|
hex = HexCharacters[value & 0x0f] + hex;
|
||||||
|
value = parseInt(value / 16);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (hex.length) {
|
||||||
|
if (hex.length % 2) { hex = '0' + hex; }
|
||||||
|
return '0x' + hex;
|
||||||
|
}
|
||||||
|
|
||||||
|
return '0x00';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isHexString(value)) {
|
||||||
|
if (value.length % 2) {
|
||||||
|
value = '0x0' + value.substring(2);
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isArrayish(value)) {
|
||||||
|
var result = [];
|
||||||
|
for (var i = 0; i < value.length; i++) {
|
||||||
|
var v = value[i];
|
||||||
|
result.push(HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f]);
|
||||||
|
}
|
||||||
|
return '0x' + result.join('');
|
||||||
|
}
|
||||||
|
|
||||||
|
errors.throwError('invalid hexlify value', { arg: 'value', value: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
function hexStripZeros(value) {
|
||||||
|
while (value.length > 3 && value.substring(0, 3) === '0x0') {
|
||||||
|
value = '0x' + value.substring(3);
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
function hexZeroPad(value, length) {
|
||||||
|
while (value.length < 2 * length + 2) {
|
||||||
|
value = '0x0' + value.substring(2);
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* @TODO: Add something like this to make slicing code easier to understand
|
||||||
|
function hexSlice(hex, start, end) {
|
||||||
|
hex = hexlify(hex);
|
||||||
|
return '0x' + hex.substring(2 + start * 2, 2 + end * 2);
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
function splitSignature(signature) {
|
||||||
|
signature = arrayify(signature);
|
||||||
|
if (signature.length !== 65) {
|
||||||
|
throw new Error('invalid signature');
|
||||||
|
}
|
||||||
|
|
||||||
|
var v = signature[64];
|
||||||
|
if (v !== 27 && v !== 28) {
|
||||||
|
v = 27 + (v % 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
return {
|
||||||
|
r: hexlify(signature.slice(0, 32)),
|
||||||
|
s: hexlify(signature.slice(32, 64)),
|
||||||
|
v: v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
arrayify: arrayify,
|
||||||
|
isArrayish: isArrayish,
|
||||||
|
|
||||||
|
concat: concat,
|
||||||
|
|
||||||
|
padZeros: padZeros,
|
||||||
|
stripZeros: stripZeros,
|
||||||
|
|
||||||
|
splitSignature: splitSignature,
|
||||||
|
|
||||||
|
hexlify: hexlify,
|
||||||
|
isHexString: isHexString,
|
||||||
|
hexStripZeros: hexStripZeros,
|
||||||
|
hexZeroPad: hexZeroPad,
|
||||||
|
};
|
||||||
1
utils/empty.js
Normal file
1
utils/empty.js
Normal file
@ -0,0 +1 @@
|
|||||||
|
module.exports = undefined;
|
||||||
91
utils/errors.js
Normal file
91
utils/errors.js
Normal file
@ -0,0 +1,91 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var defineProperty = require('./properties').defineProperty;
|
||||||
|
|
||||||
|
var codes = { };
|
||||||
|
|
||||||
|
[
|
||||||
|
// Unknown Error
|
||||||
|
'UNKNOWN_ERROR',
|
||||||
|
|
||||||
|
// Not implemented
|
||||||
|
'NOT_IMPLEMENTED',
|
||||||
|
|
||||||
|
// Missing new operator to an object
|
||||||
|
// - name: The name of the class
|
||||||
|
'MISSING_NEW',
|
||||||
|
|
||||||
|
|
||||||
|
// Call exception
|
||||||
|
'CALL_EXCEPTION',
|
||||||
|
|
||||||
|
|
||||||
|
// Response from a server was invalid
|
||||||
|
// - response: The body of the response
|
||||||
|
//'BAD_RESPONSE',
|
||||||
|
|
||||||
|
|
||||||
|
// Invalid argument (e.g. type) to a function:
|
||||||
|
// - arg: The argument name that was invalid
|
||||||
|
// - value: The value of the argument
|
||||||
|
// - type: The type of the argument
|
||||||
|
// - expected: What was expected
|
||||||
|
'INVALID_ARGUMENT',
|
||||||
|
|
||||||
|
// Missing argument to a function:
|
||||||
|
// - arg: The argument name that is required
|
||||||
|
// - count: The number of arguments received
|
||||||
|
// - expectedCount: The number of arguments expected
|
||||||
|
'MISSING_ARGUMENT',
|
||||||
|
|
||||||
|
// Too many arguments
|
||||||
|
// - count: The number of arguments received
|
||||||
|
// - expectedCount: The number of arguments expected
|
||||||
|
'UNEXPECTED_ARGUMENT',
|
||||||
|
|
||||||
|
|
||||||
|
// Unsupported operation
|
||||||
|
// - operation
|
||||||
|
'UNSUPPORTED_OPERATION',
|
||||||
|
|
||||||
|
|
||||||
|
].forEach(function(code) {
|
||||||
|
defineProperty(codes, code, code);
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
defineProperty(codes, 'throwError', function(message, code, params) {
|
||||||
|
if (!code) { code = codes.UNKNOWN_ERROR; }
|
||||||
|
if (!params) { params = {}; }
|
||||||
|
|
||||||
|
var messageDetails = [];
|
||||||
|
Object.keys(params).forEach(function(key) {
|
||||||
|
try {
|
||||||
|
messageDetails.push(key + '=' + JSON.stringify(params[key]));
|
||||||
|
} catch (error) {
|
||||||
|
messageDetails.push(key + '=' + JSON.stringify(params[key].toString()));
|
||||||
|
}
|
||||||
|
});
|
||||||
|
var reason = message;
|
||||||
|
if (messageDetails.length) {
|
||||||
|
message += ' (' + messageDetails.join(', ') + ')';
|
||||||
|
}
|
||||||
|
|
||||||
|
var error = new Error(message);
|
||||||
|
error.reason = reason;
|
||||||
|
error.code = code
|
||||||
|
|
||||||
|
Object.keys(params).forEach(function(key) {
|
||||||
|
error[key] = params[key];
|
||||||
|
});
|
||||||
|
|
||||||
|
throw error;
|
||||||
|
});
|
||||||
|
|
||||||
|
defineProperty(codes, 'checkNew', function(self, kind) {
|
||||||
|
if (!(self instanceof kind)) {
|
||||||
|
codes.throwError('missing new', codes.MISSING_NEW, { name: kind.name });
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
module.exports = codes;
|
||||||
259
utils/hdnode.js
Normal file
259
utils/hdnode.js
Normal file
@ -0,0 +1,259 @@
|
|||||||
|
// See: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
|
||||||
|
// See: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
|
||||||
|
|
||||||
|
var secp256k1 = new (require('elliptic')).ec('secp256k1');
|
||||||
|
|
||||||
|
var wordlist = (function() {
|
||||||
|
var words = require('./words.json');
|
||||||
|
return words.replace(/([A-Z])/g, ' $1').toLowerCase().substring(1).split(' ');
|
||||||
|
})();
|
||||||
|
|
||||||
|
var utils = (function() {
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
var sha2 = require('./sha2');
|
||||||
|
|
||||||
|
var hmac = require('./hmac');
|
||||||
|
|
||||||
|
return {
|
||||||
|
defineProperty: require('./properties.js').defineProperty,
|
||||||
|
|
||||||
|
arrayify: convert.arrayify,
|
||||||
|
bigNumberify: require('./bignumber.js').bigNumberify,
|
||||||
|
hexlify: convert.hexlify,
|
||||||
|
|
||||||
|
toUtf8Bytes: require('./utf8.js').toUtf8Bytes,
|
||||||
|
|
||||||
|
sha256: sha2.sha256,
|
||||||
|
createSha512Hmac: hmac.createSha512Hmac,
|
||||||
|
|
||||||
|
pbkdf2: require('./pbkdf2.js'),
|
||||||
|
}
|
||||||
|
})();
|
||||||
|
|
||||||
|
// "Bitcoin seed"
|
||||||
|
var MasterSecret = utils.toUtf8Bytes('Bitcoin seed');
|
||||||
|
|
||||||
|
var HardenedBit = 0x80000000;
|
||||||
|
|
||||||
|
// Returns a byte with the MSB bits set
|
||||||
|
function getUpperMask(bits) {
|
||||||
|
return ((1 << bits) - 1) << (8 - bits);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns a byte with the LSB bits set
|
||||||
|
function getLowerMask(bits) {
|
||||||
|
return (1 << bits) - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
function HDNode(keyPair, chainCode, index, depth) {
|
||||||
|
if (!(this instanceof HDNode)) { throw new Error('missing new'); }
|
||||||
|
|
||||||
|
utils.defineProperty(this, '_keyPair', keyPair);
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'privateKey', utils.hexlify(keyPair.priv.toArray('be', 32)));
|
||||||
|
utils.defineProperty(this, 'publicKey', '0x' + keyPair.getPublic(true, 'hex'));
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'chainCode', utils.hexlify(chainCode));
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'index', index);
|
||||||
|
utils.defineProperty(this, 'depth', depth);
|
||||||
|
}
|
||||||
|
|
||||||
|
utils.defineProperty(HDNode.prototype, '_derive', function(index) {
|
||||||
|
|
||||||
|
// Public parent key -> public child key
|
||||||
|
if (!this.privateKey) {
|
||||||
|
if (index >= HardenedBit) { throw new Error('cannot derive child of neutered node'); }
|
||||||
|
throw new Error('not implemented');
|
||||||
|
}
|
||||||
|
|
||||||
|
var data = new Uint8Array(37);
|
||||||
|
|
||||||
|
if (index & HardenedBit) {
|
||||||
|
// Data = 0x00 || ser_256(k_par)
|
||||||
|
data.set(utils.arrayify(this.privateKey), 1);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
// Data = ser_p(point(k_par))
|
||||||
|
data.set(this._keyPair.getPublic().encode(null, true));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Data += ser_32(i)
|
||||||
|
for (var i = 24; i >= 0; i -= 8) { data[33 + (i >> 3)] = ((index >> (24 - i)) & 0xff); }
|
||||||
|
|
||||||
|
var I = utils.arrayify(utils.createSha512Hmac(this.chainCode).update(data).digest());
|
||||||
|
var IL = utils.bigNumberify(I.slice(0, 32));
|
||||||
|
var IR = I.slice(32);
|
||||||
|
|
||||||
|
var ki = IL.add('0x' + this._keyPair.getPrivate('hex')).mod('0x' + secp256k1.curve.n.toString(16));
|
||||||
|
|
||||||
|
return new HDNode(secp256k1.keyFromPrivate(utils.arrayify(ki)), I.slice(32), index, this.depth + 1);
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(HDNode.prototype, 'derivePath', function(path) {
|
||||||
|
var components = path.split('/');
|
||||||
|
|
||||||
|
if (components.length === 0 || (components[0] === 'm' && this.depth !== 0)) {
|
||||||
|
throw new Error('invalid path');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (components[0] === 'm') { components.shift(); }
|
||||||
|
|
||||||
|
var result = this;
|
||||||
|
for (var i = 0; i < components.length; i++) {
|
||||||
|
var component = components[i];
|
||||||
|
if (component.match(/^[0-9]+'$/)) {
|
||||||
|
var index = parseInt(component.substring(0, component.length - 1));
|
||||||
|
if (index >= HardenedBit) { throw new Error('invalid path index - ' + component); }
|
||||||
|
result = result._derive(HardenedBit + index);
|
||||||
|
} else if (component.match(/^[0-9]+$/)) {
|
||||||
|
var index = parseInt(component);
|
||||||
|
if (index >= HardenedBit) { throw new Error('invalid path index - ' + component); }
|
||||||
|
result = result._derive(index);
|
||||||
|
} else {
|
||||||
|
throw new Error('invlaid path component - ' + component);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(HDNode, 'fromMnemonic', function(mnemonic) {
|
||||||
|
// Check that the checksum s valid (will throw an error)
|
||||||
|
mnemonicToEntropy(mnemonic);
|
||||||
|
|
||||||
|
return HDNode.fromSeed(mnemonicToSeed(mnemonic));
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(HDNode, 'fromSeed', function(seed) {
|
||||||
|
seed = utils.arrayify(seed);
|
||||||
|
if (seed.length < 16 || seed.length > 64) { throw new Error('invalid seed'); }
|
||||||
|
|
||||||
|
var I = utils.arrayify(utils.createSha512Hmac(MasterSecret).update(seed).digest());
|
||||||
|
|
||||||
|
return new HDNode(secp256k1.keyFromPrivate(I.slice(0, 32)), I.slice(32), 0, 0, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
function mnemonicToSeed(mnemonic, password) {
|
||||||
|
|
||||||
|
if (!password) {
|
||||||
|
password = '';
|
||||||
|
|
||||||
|
} else if (password.normalize) {
|
||||||
|
password = password.normalize('NFKD');
|
||||||
|
|
||||||
|
} else {
|
||||||
|
for (var i = 0; i < password.length; i++) {
|
||||||
|
var c = password.charCodeAt(i);
|
||||||
|
if (c < 32 || c > 127) { throw new Error('passwords with non-ASCII characters not supported in this environment'); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mnemonic = utils.toUtf8Bytes(mnemonic, 'NFKD');
|
||||||
|
var salt = utils.toUtf8Bytes('mnemonic' + password, 'NFKD');
|
||||||
|
|
||||||
|
return utils.hexlify(utils.pbkdf2(mnemonic, salt, 2048, 64, utils.createSha512Hmac));
|
||||||
|
}
|
||||||
|
|
||||||
|
function mnemonicToEntropy(mnemonic) {
|
||||||
|
var words = mnemonic.toLowerCase().split(' ');
|
||||||
|
if ((words.length % 3) !== 0) { throw new Error('invalid mnemonic'); }
|
||||||
|
|
||||||
|
var entropy = utils.arrayify(new Uint8Array(Math.ceil(11 * words.length / 8)));
|
||||||
|
|
||||||
|
var offset = 0;
|
||||||
|
for (var i = 0; i < words.length; i++) {
|
||||||
|
var index = wordlist.indexOf(words[i]);
|
||||||
|
if (index === -1) { throw new Error('invalid mnemonic'); }
|
||||||
|
|
||||||
|
for (var bit = 0; bit < 11; bit++) {
|
||||||
|
if (index & (1 << (10 - bit))) {
|
||||||
|
entropy[offset >> 3] |= (1 << (7 - (offset % 8)));
|
||||||
|
}
|
||||||
|
offset++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var entropyBits = 32 * words.length / 3;
|
||||||
|
|
||||||
|
var checksumBits = words.length / 3;
|
||||||
|
var checksumMask = getUpperMask(checksumBits);
|
||||||
|
|
||||||
|
var checksum = utils.arrayify(utils.sha256(entropy.slice(0, entropyBits / 8)))[0];
|
||||||
|
checksum &= checksumMask;
|
||||||
|
|
||||||
|
if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
|
||||||
|
throw new Error('invalid checksum');
|
||||||
|
}
|
||||||
|
|
||||||
|
return utils.hexlify(entropy.slice(0, entropyBits / 8));
|
||||||
|
}
|
||||||
|
|
||||||
|
function entropyToMnemonic(entropy) {
|
||||||
|
entropy = utils.arrayify(entropy);
|
||||||
|
|
||||||
|
if ((entropy.length % 4) !== 0 || entropy.length < 16 || entropy.length > 32) {
|
||||||
|
throw new Error('invalid entropy');
|
||||||
|
}
|
||||||
|
|
||||||
|
var words = [0];
|
||||||
|
|
||||||
|
var remainingBits = 11;
|
||||||
|
for (var i = 0; i < entropy.length; i++) {
|
||||||
|
|
||||||
|
// Consume the whole byte (with still more to go)
|
||||||
|
if (remainingBits > 8) {
|
||||||
|
words[words.length - 1] <<= 8;
|
||||||
|
words[words.length - 1] |= entropy[i];
|
||||||
|
|
||||||
|
remainingBits -= 8;
|
||||||
|
|
||||||
|
// This byte will complete an 11-bit index
|
||||||
|
} else {
|
||||||
|
words[words.length - 1] <<= remainingBits;
|
||||||
|
words[words.length - 1] |= entropy[i] >> (8 - remainingBits);
|
||||||
|
|
||||||
|
// Start the next word
|
||||||
|
words.push(entropy[i] & getLowerMask(8 - remainingBits));
|
||||||
|
|
||||||
|
remainingBits += 3;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compute the checksum bits
|
||||||
|
var checksum = utils.arrayify(utils.sha256(entropy))[0];
|
||||||
|
var checksumBits = entropy.length / 4;
|
||||||
|
checksum &= getUpperMask(checksumBits);
|
||||||
|
|
||||||
|
// Shift the checksum into the word indices
|
||||||
|
words[words.length - 1] <<= checksumBits;
|
||||||
|
words[words.length - 1] |= (checksum >> (8 - checksumBits));
|
||||||
|
|
||||||
|
// Convert indices into words
|
||||||
|
for (var i = 0; i < words.length; i++) {
|
||||||
|
words[i] = wordlist[words[i]];
|
||||||
|
}
|
||||||
|
|
||||||
|
return words.join(' ');
|
||||||
|
}
|
||||||
|
|
||||||
|
function isValidMnemonic(mnemonic) {
|
||||||
|
try {
|
||||||
|
mnemonicToEntropy(mnemonic);
|
||||||
|
return true;
|
||||||
|
} catch (error) { }
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
fromMnemonic: HDNode.fromMnemonic,
|
||||||
|
fromSeed: HDNode.fromSeed,
|
||||||
|
|
||||||
|
mnemonicToSeed: mnemonicToSeed,
|
||||||
|
mnemonicToEntropy: mnemonicToEntropy,
|
||||||
|
entropyToMnemonic: entropyToMnemonic,
|
||||||
|
|
||||||
|
isValidMnemonic: isValidMnemonic,
|
||||||
|
};
|
||||||
24
utils/hmac.js
Normal file
24
utils/hmac.js
Normal file
@ -0,0 +1,24 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var hash = require('hash.js');
|
||||||
|
|
||||||
|
var sha2 = require('./sha2.js');
|
||||||
|
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
// @TODO: Make this use create-hmac in node
|
||||||
|
|
||||||
|
function createSha256Hmac(key) {
|
||||||
|
if (!key.buffer) { key = convert.arrayify(key); }
|
||||||
|
return new hash.hmac(sha2.createSha256, key);
|
||||||
|
}
|
||||||
|
|
||||||
|
function createSha512Hmac(key) {
|
||||||
|
if (!key.buffer) { key = convert.arrayify(key); }
|
||||||
|
return new hash.hmac(sha2.createSha512, key);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
createSha256Hmac: createSha256Hmac,
|
||||||
|
createSha512Hmac: createSha512Hmac,
|
||||||
|
};
|
||||||
10
utils/id.js
Normal file
10
utils/id.js
Normal file
@ -0,0 +1,10 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var keccak256 = require('./keccak256');
|
||||||
|
var utf8 = require('./utf8');
|
||||||
|
|
||||||
|
function id(text) {
|
||||||
|
return keccak256(utf8.toUtf8Bytes(text));
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = id;
|
||||||
75
utils/index.js
Normal file
75
utils/index.js
Normal file
@ -0,0 +1,75 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
// This is SUPER useful, but adds 140kb (even zipped, adds 40kb)
|
||||||
|
//var unorm = require('unorm');
|
||||||
|
|
||||||
|
var address = require('./address');
|
||||||
|
var AbiCoder = require('./abi-coder');
|
||||||
|
var base64 = require('./base64');
|
||||||
|
var bigNumber = require('./bignumber');
|
||||||
|
var contractAddress = require('./contract-address');
|
||||||
|
var convert = require('./convert');
|
||||||
|
var id = require('./id');
|
||||||
|
var keccak256 = require('./keccak256');
|
||||||
|
var namehash = require('./namehash');
|
||||||
|
var sha256 = require('./sha2').sha256;
|
||||||
|
var solidity = require('./solidity');
|
||||||
|
var randomBytes = require('./random-bytes');
|
||||||
|
var properties = require('./properties');
|
||||||
|
var RLP = require('./rlp');
|
||||||
|
var utf8 = require('./utf8');
|
||||||
|
var units = require('./units');
|
||||||
|
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
AbiCoder: AbiCoder,
|
||||||
|
|
||||||
|
RLP: RLP,
|
||||||
|
|
||||||
|
defineProperty: properties.defineProperty,
|
||||||
|
|
||||||
|
// NFKD (decomposed)
|
||||||
|
//etherSymbol: '\uD835\uDF63',
|
||||||
|
|
||||||
|
// NFKC (composed)
|
||||||
|
etherSymbol: '\u039e',
|
||||||
|
|
||||||
|
arrayify: convert.arrayify,
|
||||||
|
|
||||||
|
concat: convert.concat,
|
||||||
|
padZeros: convert.padZeros,
|
||||||
|
stripZeros: convert.stripZeros,
|
||||||
|
|
||||||
|
base64: base64,
|
||||||
|
|
||||||
|
bigNumberify: bigNumber.bigNumberify,
|
||||||
|
BigNumber: bigNumber.BigNumber,
|
||||||
|
|
||||||
|
hexlify: convert.hexlify,
|
||||||
|
|
||||||
|
toUtf8Bytes: utf8.toUtf8Bytes,
|
||||||
|
toUtf8String: utf8.toUtf8String,
|
||||||
|
|
||||||
|
namehash: namehash,
|
||||||
|
id: id,
|
||||||
|
|
||||||
|
getAddress: address.getAddress,
|
||||||
|
getContractAddress: contractAddress.getContractAddress,
|
||||||
|
|
||||||
|
formatEther: units.formatEther,
|
||||||
|
parseEther: units.parseEther,
|
||||||
|
|
||||||
|
formatUnits: units.formatUnits,
|
||||||
|
parseUnits: units.parseUnits,
|
||||||
|
|
||||||
|
keccak256: keccak256,
|
||||||
|
sha256: sha256,
|
||||||
|
|
||||||
|
randomBytes: randomBytes,
|
||||||
|
|
||||||
|
solidityPack: solidity.pack,
|
||||||
|
solidityKeccak256: solidity.keccak256,
|
||||||
|
soliditySha256: solidity.sha256,
|
||||||
|
|
||||||
|
splitSignature: convert.splitSignature,
|
||||||
|
}
|
||||||
12
utils/keccak256.js
Normal file
12
utils/keccak256.js
Normal file
@ -0,0 +1,12 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var sha3 = require('js-sha3');
|
||||||
|
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
function keccak256(data) {
|
||||||
|
data = convert.arrayify(data);
|
||||||
|
return '0x' + sha3.keccak_256(data);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = keccak256;
|
||||||
38
utils/namehash.js
Normal file
38
utils/namehash.js
Normal file
@ -0,0 +1,38 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
var utf8 = require('./utf8');
|
||||||
|
var keccak256 = require('./keccak256');
|
||||||
|
|
||||||
|
var Zeros = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
||||||
|
var Partition = new RegExp("^((.*)\\.)?([^.]+)$");
|
||||||
|
var UseSTD3ASCIIRules = new RegExp("^[a-z0-9.-]*$");
|
||||||
|
|
||||||
|
function namehash(name, depth) {
|
||||||
|
name = name.toLowerCase();
|
||||||
|
|
||||||
|
// Supporting the full UTF-8 space requires additional (and large)
|
||||||
|
// libraries, so for now we simply do not support them.
|
||||||
|
// It should be fairly easy in the future to support systems with
|
||||||
|
// String.normalize, but that is future work.
|
||||||
|
if (!name.match(UseSTD3ASCIIRules)) {
|
||||||
|
throw new Error('contains invalid UseSTD3ASCIIRules characters');
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = Zeros;
|
||||||
|
var processed = 0;
|
||||||
|
while (name.length && (!depth || processed < depth)) {
|
||||||
|
var partition = name.match(Partition);
|
||||||
|
var label = utf8.toUtf8Bytes(partition[3]);
|
||||||
|
result = keccak256(convert.concat([result, keccak256(label)]));
|
||||||
|
|
||||||
|
name = partition[2] || '';
|
||||||
|
|
||||||
|
processed++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return convert.hexlify(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = namehash;
|
||||||
|
|
||||||
51
utils/pbkdf2.js
Normal file
51
utils/pbkdf2.js
Normal file
@ -0,0 +1,51 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var convert = require('./convert');
|
||||||
|
|
||||||
|
function pbkdf2(password, salt, iterations, keylen, createHmac) {
|
||||||
|
var hLen
|
||||||
|
var l = 1
|
||||||
|
var DK = new Uint8Array(keylen)
|
||||||
|
var block1 = new Uint8Array(salt.length + 4)
|
||||||
|
block1.set(salt);
|
||||||
|
//salt.copy(block1, 0, 0, salt.length)
|
||||||
|
|
||||||
|
var r
|
||||||
|
var T
|
||||||
|
|
||||||
|
for (var i = 1; i <= l; i++) {
|
||||||
|
//block1.writeUInt32BE(i, salt.length)
|
||||||
|
block1[salt.length] = (i >> 24) & 0xff;
|
||||||
|
block1[salt.length + 1] = (i >> 16) & 0xff;
|
||||||
|
block1[salt.length + 2] = (i >> 8) & 0xff;
|
||||||
|
block1[salt.length + 3] = i & 0xff;
|
||||||
|
|
||||||
|
var U = createHmac(password).update(block1).digest();
|
||||||
|
|
||||||
|
if (!hLen) {
|
||||||
|
hLen = U.length
|
||||||
|
T = new Uint8Array(hLen)
|
||||||
|
l = Math.ceil(keylen / hLen)
|
||||||
|
r = keylen - (l - 1) * hLen
|
||||||
|
}
|
||||||
|
|
||||||
|
//U.copy(T, 0, 0, hLen)
|
||||||
|
T.set(U);
|
||||||
|
|
||||||
|
|
||||||
|
for (var j = 1; j < iterations; j++) {
|
||||||
|
U = createHmac(password).update(U).digest()
|
||||||
|
for (var k = 0; k < hLen; k++) T[k] ^= U[k]
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
var destPos = (i - 1) * hLen
|
||||||
|
var len = (i === l ? r : hLen)
|
||||||
|
//T.copy(DK, destPos, 0, len)
|
||||||
|
DK.set(convert.arrayify(T).slice(0, len), destPos);
|
||||||
|
}
|
||||||
|
|
||||||
|
return convert.arrayify(DK)
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = pbkdf2;
|
||||||
22
utils/properties.js
Normal file
22
utils/properties.js
Normal file
@ -0,0 +1,22 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
function defineProperty(object, name, value) {
|
||||||
|
Object.defineProperty(object, name, {
|
||||||
|
enumerable: true,
|
||||||
|
value: value,
|
||||||
|
writable: false,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function defineFrozen(object, name, value) {
|
||||||
|
var frozen = JSON.stringify(value);
|
||||||
|
Object.defineProperty(object, name, {
|
||||||
|
enumerable: true,
|
||||||
|
get: function() { return JSON.parse(frozen); }
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
defineFrozen: defineFrozen,
|
||||||
|
defineProperty: defineProperty,
|
||||||
|
};
|
||||||
8
utils/random-bytes.js
Normal file
8
utils/random-bytes.js
Normal file
@ -0,0 +1,8 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var randomBytes = require('crypto').randomBytes;
|
||||||
|
|
||||||
|
module.exports = function(length) {
|
||||||
|
return new Uint8Array(randomBytes(length));
|
||||||
|
}
|
||||||
|
|
||||||
142
utils/rlp.js
Normal file
142
utils/rlp.js
Normal file
@ -0,0 +1,142 @@
|
|||||||
|
//See: https://github.com/ethereum/wiki/wiki/RLP
|
||||||
|
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
function arrayifyInteger(value) {
|
||||||
|
var result = [];
|
||||||
|
while (value) {
|
||||||
|
result.unshift(value & 0xff);
|
||||||
|
value >>= 8;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
function unarrayifyInteger(data, offset, length) {
|
||||||
|
var result = 0;
|
||||||
|
for (var i = 0; i < length; i++) {
|
||||||
|
result = (result * 256) + data[offset + i];
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
function _encode(object) {
|
||||||
|
if (Array.isArray(object)) {
|
||||||
|
var payload = [];
|
||||||
|
object.forEach(function(child) {
|
||||||
|
payload = payload.concat(_encode(child));
|
||||||
|
});
|
||||||
|
|
||||||
|
if (payload.length <= 55) {
|
||||||
|
payload.unshift(0xc0 + payload.length)
|
||||||
|
return payload;
|
||||||
|
}
|
||||||
|
|
||||||
|
var length = arrayifyInteger(payload.length);
|
||||||
|
length.unshift(0xf7 + length.length);
|
||||||
|
|
||||||
|
return length.concat(payload);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
object = [].slice.call(convert.arrayify(object));
|
||||||
|
|
||||||
|
if (object.length === 1 && object[0] <= 0x7f) {
|
||||||
|
return object;
|
||||||
|
|
||||||
|
} else if (object.length <= 55) {
|
||||||
|
object.unshift(0x80 + object.length);
|
||||||
|
return object
|
||||||
|
}
|
||||||
|
|
||||||
|
var length = arrayifyInteger(object.length);
|
||||||
|
length.unshift(0xb7 + length.length);
|
||||||
|
|
||||||
|
return length.concat(object);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function encode(object) {
|
||||||
|
return convert.hexlify(_encode(object));
|
||||||
|
}
|
||||||
|
|
||||||
|
function _decodeChildren(data, offset, childOffset, length) {
|
||||||
|
var result = [];
|
||||||
|
|
||||||
|
while (childOffset < offset + 1 + length) {
|
||||||
|
var decoded = _decode(data, childOffset);
|
||||||
|
|
||||||
|
result.push(decoded.result);
|
||||||
|
|
||||||
|
childOffset += decoded.consumed;
|
||||||
|
if (childOffset > offset + 1 + length) {
|
||||||
|
throw new Error('invalid rlp');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return {consumed: (1 + length), result: result};
|
||||||
|
}
|
||||||
|
|
||||||
|
// returns { consumed: number, result: Object }
|
||||||
|
function _decode(data, offset) {
|
||||||
|
if (data.length === 0) { throw new Error('invalid rlp data'); }
|
||||||
|
|
||||||
|
// Array with extra length prefix
|
||||||
|
if (data[offset] >= 0xf8) {
|
||||||
|
var lengthLength = data[offset] - 0xf7;
|
||||||
|
if (offset + 1 + lengthLength > data.length) {
|
||||||
|
throw new Error('too short');
|
||||||
|
}
|
||||||
|
|
||||||
|
var length = unarrayifyInteger(data, offset + 1, lengthLength);
|
||||||
|
if (offset + 1 + lengthLength + length > data.length) {
|
||||||
|
throw new Error('to short');
|
||||||
|
}
|
||||||
|
|
||||||
|
return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
|
||||||
|
|
||||||
|
} else if (data[offset] >= 0xc0) {
|
||||||
|
var length = data[offset] - 0xc0;
|
||||||
|
if (offset + 1 + length > data.length) {
|
||||||
|
throw new Error('invalid rlp data');
|
||||||
|
}
|
||||||
|
|
||||||
|
return _decodeChildren(data, offset, offset + 1, length);
|
||||||
|
|
||||||
|
} else if (data[offset] >= 0xb8) {
|
||||||
|
var lengthLength = data[offset] - 0xb7;
|
||||||
|
if (offset + 1 + lengthLength > data.length) {
|
||||||
|
throw new Error('invalid rlp data');
|
||||||
|
}
|
||||||
|
|
||||||
|
var length = unarrayifyInteger(data, offset + 1, lengthLength);
|
||||||
|
if (offset + 1 + lengthLength + length > data.length) {
|
||||||
|
throw new Error('invalid rlp data');
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = convert.hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
|
||||||
|
return { consumed: (1 + lengthLength + length), result: result }
|
||||||
|
|
||||||
|
} else if (data[offset] >= 0x80) {
|
||||||
|
var length = data[offset] - 0x80;
|
||||||
|
if (offset + 1 + length > data.offset) {
|
||||||
|
throw new Error('invlaid rlp data');
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = convert.hexlify(data.slice(offset + 1, offset + 1 + length));
|
||||||
|
return { consumed: (1 + length), result: result }
|
||||||
|
}
|
||||||
|
return { consumed: 1, result: convert.hexlify(data[offset]) };
|
||||||
|
}
|
||||||
|
|
||||||
|
function decode(data) {
|
||||||
|
data = convert.arrayify(data);
|
||||||
|
var decoded = _decode(data, 0);
|
||||||
|
if (decoded.consumed !== data.length) {
|
||||||
|
throw new Error('invalid rlp data');
|
||||||
|
}
|
||||||
|
return decoded.result;
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
encode: encode,
|
||||||
|
decode: decode,
|
||||||
|
}
|
||||||
449
utils/secret-storage.js
Normal file
449
utils/secret-storage.js
Normal file
@ -0,0 +1,449 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var aes = require('aes-js');
|
||||||
|
var scrypt = require('scrypt-js');
|
||||||
|
var uuid = require('uuid');
|
||||||
|
|
||||||
|
var hmac = require('../utils/hmac');
|
||||||
|
var pbkdf2 = require('../utils/pbkdf2');
|
||||||
|
var utils = require('../util.js');
|
||||||
|
|
||||||
|
var SigningKey = require('./signing-key');
|
||||||
|
var HDNode = require('./hdnode');
|
||||||
|
|
||||||
|
// @TODO: Maybe move this to HDNode?
|
||||||
|
var defaultPath = "m/44'/60'/0'/0/0";
|
||||||
|
|
||||||
|
function arrayify(hexString) {
|
||||||
|
if (typeof(hexString) === 'string' && hexString.substring(0, 2) !== '0x') {
|
||||||
|
hexString = '0x' + hexString;
|
||||||
|
}
|
||||||
|
return utils.arrayify(hexString);
|
||||||
|
}
|
||||||
|
|
||||||
|
function zpad(value, length) {
|
||||||
|
value = String(value);
|
||||||
|
while (value.length < length) { value = '0' + value; }
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
function getPassword(password) {
|
||||||
|
if (typeof(password) === 'string') {
|
||||||
|
return utils.toUtf8Bytes(password, 'NFKC');
|
||||||
|
}
|
||||||
|
return utils.arrayify(password, 'password');
|
||||||
|
}
|
||||||
|
|
||||||
|
// Search an Object and its children recursively, caselessly.
|
||||||
|
function searchPath(object, path) {
|
||||||
|
var currentChild = object;
|
||||||
|
|
||||||
|
var comps = path.toLowerCase().split('/');
|
||||||
|
for (var i = 0; i < comps.length; i++) {
|
||||||
|
|
||||||
|
// Search for a child object with a case-insensitive matching key
|
||||||
|
var matchingChild = null;
|
||||||
|
for (var key in currentChild) {
|
||||||
|
if (key.toLowerCase() === comps[i]) {
|
||||||
|
matchingChild = currentChild[key];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Didn't find one. :'(
|
||||||
|
if (matchingChild === null) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Now check this child...
|
||||||
|
currentChild = matchingChild;
|
||||||
|
}
|
||||||
|
|
||||||
|
return currentChild;
|
||||||
|
}
|
||||||
|
|
||||||
|
var secretStorage = {};
|
||||||
|
|
||||||
|
|
||||||
|
utils.defineProperty(secretStorage, 'isCrowdsaleWallet', function(json) {
|
||||||
|
try {
|
||||||
|
var data = JSON.parse(json);
|
||||||
|
} catch (error) { return false; }
|
||||||
|
|
||||||
|
return (data.encseed && data.ethaddr);
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(secretStorage, 'isValidWallet', function(json) {
|
||||||
|
try {
|
||||||
|
var data = JSON.parse(json);
|
||||||
|
} catch (error) { return false; }
|
||||||
|
|
||||||
|
if (!data.version || parseInt(data.version) !== data.version || parseInt(data.version) !== 3) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// @TODO: Put more checks to make sure it has kdf, iv and all that good stuff
|
||||||
|
return true;
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
// See: https://github.com/ethereum/pyethsaletool
|
||||||
|
utils.defineProperty(secretStorage, 'decryptCrowdsale', function(json, password) {
|
||||||
|
var data = JSON.parse(json);
|
||||||
|
|
||||||
|
password = getPassword(password);
|
||||||
|
|
||||||
|
// Ethereum Address
|
||||||
|
var ethaddr = utils.getAddress(searchPath(data, 'ethaddr'));
|
||||||
|
|
||||||
|
// Encrypted Seed
|
||||||
|
var encseed = arrayify(searchPath(data, 'encseed'));
|
||||||
|
if (!encseed || (encseed.length % 16) !== 0) {
|
||||||
|
throw new Error('invalid encseed');
|
||||||
|
}
|
||||||
|
|
||||||
|
var key = pbkdf2(password, password, 2000, 32, hmac.createSha256Hmac).slice(0, 16);
|
||||||
|
|
||||||
|
var iv = encseed.slice(0, 16);
|
||||||
|
var encryptedSeed = encseed.slice(16);
|
||||||
|
|
||||||
|
// Decrypt the seed
|
||||||
|
var aesCbc = new aes.ModeOfOperation.cbc(key, iv);
|
||||||
|
var seed = utils.arrayify(aesCbc.decrypt(encryptedSeed));
|
||||||
|
seed = aes.padding.pkcs7.strip(seed);
|
||||||
|
|
||||||
|
// This wallet format is weird... Convert the binary encoded hex to a string.
|
||||||
|
var seedHex = '';
|
||||||
|
for (var i = 0; i < seed.length; i++) {
|
||||||
|
seedHex += String.fromCharCode(seed[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
var seedHexBytes = utils.toUtf8Bytes(seedHex);
|
||||||
|
|
||||||
|
var signingKey = new SigningKey(utils.keccak256(seedHexBytes));
|
||||||
|
|
||||||
|
if (signingKey.address !== ethaddr) {
|
||||||
|
throw new Error('corrupt crowdsale wallet');
|
||||||
|
}
|
||||||
|
|
||||||
|
return signingKey;
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
utils.defineProperty(secretStorage, 'decrypt', function(json, password, progressCallback) {
|
||||||
|
var data = JSON.parse(json);
|
||||||
|
|
||||||
|
password = getPassword(password);
|
||||||
|
|
||||||
|
var decrypt = function(key, ciphertext) {
|
||||||
|
var cipher = searchPath(data, 'crypto/cipher');
|
||||||
|
if (cipher === 'aes-128-ctr') {
|
||||||
|
var iv = arrayify(searchPath(data, 'crypto/cipherparams/iv'), 'crypto/cipherparams/iv')
|
||||||
|
var counter = new aes.Counter(iv);
|
||||||
|
|
||||||
|
var aesCtr = new aes.ModeOfOperation.ctr(key, counter);
|
||||||
|
|
||||||
|
return arrayify(aesCtr.decrypt(ciphertext));
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
};
|
||||||
|
|
||||||
|
var computeMAC = function(derivedHalf, ciphertext) {
|
||||||
|
return utils.keccak256(utils.concat([derivedHalf, ciphertext]));
|
||||||
|
}
|
||||||
|
|
||||||
|
var getSigningKey = function(key, reject) {
|
||||||
|
var ciphertext = arrayify(searchPath(data, 'crypto/ciphertext'));
|
||||||
|
|
||||||
|
var computedMAC = utils.hexlify(computeMAC(key.slice(16, 32), ciphertext)).substring(2);
|
||||||
|
if (computedMAC !== searchPath(data, 'crypto/mac').toLowerCase()) {
|
||||||
|
reject(new Error('invalid password'));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
var privateKey = decrypt(key.slice(0, 16), ciphertext);
|
||||||
|
var mnemonicKey = key.slice(32, 64);
|
||||||
|
|
||||||
|
if (!privateKey) {
|
||||||
|
reject(new Error('unsupported cipher'));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
var signingKey = new SigningKey(privateKey);
|
||||||
|
if (signingKey.address !== utils.getAddress(data.address)) {
|
||||||
|
reject(new Error('address mismatch'));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase
|
||||||
|
if (searchPath(data, 'x-ethers/version') === '0.1') {
|
||||||
|
var mnemonicCiphertext = arrayify(searchPath(data, 'x-ethers/mnemonicCiphertext'), 'x-ethers/mnemonicCiphertext');
|
||||||
|
var mnemonicIv = arrayify(searchPath(data, 'x-ethers/mnemonicCounter'), 'x-ethers/mnemonicCounter');
|
||||||
|
|
||||||
|
var mnemonicCounter = new aes.Counter(mnemonicIv);
|
||||||
|
var mnemonicAesCtr = new aes.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);
|
||||||
|
|
||||||
|
var path = searchPath(data, 'x-ethers/path') || defaultPath;
|
||||||
|
|
||||||
|
var entropy = arrayify(mnemonicAesCtr.decrypt(mnemonicCiphertext));
|
||||||
|
var mnemonic = HDNode.entropyToMnemonic(entropy);
|
||||||
|
|
||||||
|
if (HDNode.fromMnemonic(mnemonic).derivePath(path).privateKey != utils.hexlify(privateKey)) {
|
||||||
|
reject(new Error('mnemonic mismatch'));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
signingKey.mnemonic = mnemonic;
|
||||||
|
signingKey.path = path;
|
||||||
|
}
|
||||||
|
|
||||||
|
return signingKey;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return new Promise(function(resolve, reject) {
|
||||||
|
var kdf = searchPath(data, 'crypto/kdf');
|
||||||
|
if (kdf && typeof(kdf) === 'string') {
|
||||||
|
if (kdf.toLowerCase() === 'scrypt') {
|
||||||
|
var salt = arrayify(searchPath(data, 'crypto/kdfparams/salt'), 'crypto/kdfparams/salt');
|
||||||
|
var N = parseInt(searchPath(data, 'crypto/kdfparams/n'));
|
||||||
|
var r = parseInt(searchPath(data, 'crypto/kdfparams/r'));
|
||||||
|
var p = parseInt(searchPath(data, 'crypto/kdfparams/p'));
|
||||||
|
if (!N || !r || !p) {
|
||||||
|
reject(new Error('unsupported key-derivation function parameters'));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make sure N is a power of 2
|
||||||
|
if ((N & (N - 1)) !== 0) {
|
||||||
|
reject(new Error('unsupported key-derivation function parameter value for N'));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var dkLen = parseInt(searchPath(data, 'crypto/kdfparams/dklen'));
|
||||||
|
if (dkLen !== 32) {
|
||||||
|
reject( new Error('unsupported key-derivation derived-key length'));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
scrypt(password, salt, N, r, p, 64, function(error, progress, key) {
|
||||||
|
if (error) {
|
||||||
|
error.progress = progress;
|
||||||
|
reject(error);
|
||||||
|
|
||||||
|
} else if (key) {
|
||||||
|
key = arrayify(key);
|
||||||
|
|
||||||
|
var signingKey = getSigningKey(key, reject);
|
||||||
|
if (!signingKey) { return; }
|
||||||
|
|
||||||
|
if (progressCallback) { progressCallback(1); }
|
||||||
|
resolve(signingKey);
|
||||||
|
|
||||||
|
} else if (progressCallback) {
|
||||||
|
return progressCallback(progress);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
} else if (kdf.toLowerCase() === 'pbkdf2') {
|
||||||
|
var salt = arrayify(searchPath(data, 'crypto/kdfparams/salt'), 'crypto/kdfparams/salt');
|
||||||
|
|
||||||
|
var prfFunc = null;
|
||||||
|
var prf = searchPath(data, 'crypto/kdfparams/prf');
|
||||||
|
if (prf === 'hmac-sha256') {
|
||||||
|
prfFunc = hmac.createSha256Hmac;
|
||||||
|
} else if (prf === 'hmac-sha512') {
|
||||||
|
prfFunc = hmac.createSha512Hmac;
|
||||||
|
} else {
|
||||||
|
reject(new Error('unsupported prf'));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var c = parseInt(searchPath(data, 'crypto/kdfparams/c'));
|
||||||
|
|
||||||
|
var dkLen = parseInt(searchPath(data, 'crypto/kdfparams/dklen'));
|
||||||
|
if (dkLen !== 32) {
|
||||||
|
reject( new Error('unsupported key-derivation derived-key length'));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var key = pbkdf2(password, salt, c, dkLen, prfFunc);
|
||||||
|
|
||||||
|
var signingKey = getSigningKey(key, reject);
|
||||||
|
if (!signingKey) { return; }
|
||||||
|
|
||||||
|
resolve(signingKey);
|
||||||
|
|
||||||
|
} else {
|
||||||
|
reject(new Error('unsupported key-derivation function'));
|
||||||
|
}
|
||||||
|
|
||||||
|
} else {
|
||||||
|
reject(new Error('unsupported key-derivation function'));
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(secretStorage, 'encrypt', function(privateKey, password, options, progressCallback) {
|
||||||
|
|
||||||
|
// the options are optional, so adjust the call as needed
|
||||||
|
if (typeof(options) === 'function' && !progressCallback) {
|
||||||
|
progressCallback = options;
|
||||||
|
options = {};
|
||||||
|
}
|
||||||
|
if (!options) { options = {}; }
|
||||||
|
|
||||||
|
// Check the private key
|
||||||
|
if (privateKey instanceof SigningKey) {
|
||||||
|
privateKey = privateKey.privateKey;
|
||||||
|
}
|
||||||
|
privateKey = arrayify(privateKey, 'private key');
|
||||||
|
if (privateKey.length !== 32) { throw new Error('invalid private key'); }
|
||||||
|
|
||||||
|
password = getPassword(password);
|
||||||
|
|
||||||
|
var entropy = options.entropy;
|
||||||
|
if (options.mnemonic) {
|
||||||
|
if (entropy) {
|
||||||
|
if (HDNode.entropyToMnemonic(entropy) !== options.mnemonic) {
|
||||||
|
throw new Error('entropy and mnemonic mismatch');
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
entropy = HDNode.mnemonicToEntropy(options.mnemonic);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (entropy) {
|
||||||
|
entropy = arrayify(entropy, 'entropy');
|
||||||
|
}
|
||||||
|
|
||||||
|
var path = options.path;
|
||||||
|
if (entropy && !path) {
|
||||||
|
path = defaultPath;
|
||||||
|
}
|
||||||
|
|
||||||
|
var client = options.client;
|
||||||
|
if (!client) { client = "ethers.js"; }
|
||||||
|
|
||||||
|
// Check/generate the salt
|
||||||
|
var salt = options.salt;
|
||||||
|
if (salt) {
|
||||||
|
salt = arrayify(salt, 'salt');
|
||||||
|
} else {
|
||||||
|
salt = utils.randomBytes(32);;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Override initialization vector
|
||||||
|
var iv = null;
|
||||||
|
if (options.iv) {
|
||||||
|
iv = arrayify(options.iv, 'iv');
|
||||||
|
if (iv.length !== 16) { throw new Error('invalid iv'); }
|
||||||
|
} else {
|
||||||
|
iv = utils.randomBytes(16);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Override the uuid
|
||||||
|
var uuidRandom = options.uuid;
|
||||||
|
if (uuidRandom) {
|
||||||
|
uuidRandom = arrayify(uuidRandom, 'uuid');
|
||||||
|
if (uuidRandom.length !== 16) { throw new Error('invalid uuid'); }
|
||||||
|
} else {
|
||||||
|
uuidRandom = utils.randomBytes(16);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Override the scrypt password-based key derivation function parameters
|
||||||
|
var N = (1 << 17), r = 8, p = 1;
|
||||||
|
if (options.scrypt) {
|
||||||
|
if (options.scrypt.N) { N = options.scrypt.N; }
|
||||||
|
if (options.scrypt.r) { r = options.scrypt.r; }
|
||||||
|
if (options.scrypt.p) { p = options.scrypt.p; }
|
||||||
|
}
|
||||||
|
|
||||||
|
return new Promise(function(resolve, reject) {
|
||||||
|
|
||||||
|
// We take 64 bytes:
|
||||||
|
// - 32 bytes As normal for the Web3 secret storage (derivedKey, macPrefix)
|
||||||
|
// - 32 bytes AES key to encrypt mnemonic with (required here to be Ethers Wallet)
|
||||||
|
scrypt(password, salt, N, r, p, 64, function(error, progress, key) {
|
||||||
|
if (error) {
|
||||||
|
error.progress = progress;
|
||||||
|
reject(error);
|
||||||
|
|
||||||
|
} else if (key) {
|
||||||
|
key = arrayify(key);
|
||||||
|
|
||||||
|
// This will be used to encrypt the wallet (as per Web3 secret storage)
|
||||||
|
var derivedKey = key.slice(0, 16);
|
||||||
|
var macPrefix = key.slice(16, 32);
|
||||||
|
|
||||||
|
// This will be used to encrypt the mnemonic phrase (if any)
|
||||||
|
var mnemonicKey = key.slice(32, 64);
|
||||||
|
|
||||||
|
// Get the address for this private key
|
||||||
|
var address = (new SigningKey(privateKey)).address;
|
||||||
|
|
||||||
|
// Encrypt the private key
|
||||||
|
var counter = new aes.Counter(iv);
|
||||||
|
var aesCtr = new aes.ModeOfOperation.ctr(derivedKey, counter);
|
||||||
|
var ciphertext = utils.arrayify(aesCtr.encrypt(privateKey));
|
||||||
|
|
||||||
|
// Compute the message authentication code, used to check the password
|
||||||
|
var mac = utils.keccak256(utils.concat([macPrefix, ciphertext]))
|
||||||
|
|
||||||
|
// See: https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition
|
||||||
|
var data = {
|
||||||
|
address: address.substring(2).toLowerCase(),
|
||||||
|
id: uuid.v4({ random: uuidRandom }),
|
||||||
|
version: 3,
|
||||||
|
Crypto: {
|
||||||
|
cipher: 'aes-128-ctr',
|
||||||
|
cipherparams: {
|
||||||
|
iv: utils.hexlify(iv).substring(2),
|
||||||
|
},
|
||||||
|
ciphertext: utils.hexlify(ciphertext).substring(2),
|
||||||
|
kdf: 'scrypt',
|
||||||
|
kdfparams: {
|
||||||
|
salt: utils.hexlify(salt).substring(2),
|
||||||
|
n: N,
|
||||||
|
dklen: 32,
|
||||||
|
p: p,
|
||||||
|
r: r
|
||||||
|
},
|
||||||
|
mac: mac.substring(2)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// If we have a mnemonic, encrypt it into the JSON wallet
|
||||||
|
if (entropy) {
|
||||||
|
var mnemonicIv = utils.randomBytes(16);
|
||||||
|
var mnemonicCounter = new aes.Counter(mnemonicIv);
|
||||||
|
var mnemonicAesCtr = new aes.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);
|
||||||
|
var mnemonicCiphertext = utils.arrayify(mnemonicAesCtr.encrypt(entropy));
|
||||||
|
var now = new Date();
|
||||||
|
var timestamp = (now.getUTCFullYear() + '-' +
|
||||||
|
zpad(now.getUTCMonth() + 1, 2) + '-' +
|
||||||
|
zpad(now.getUTCDate(), 2) + 'T' +
|
||||||
|
zpad(now.getUTCHours(), 2) + '-' +
|
||||||
|
zpad(now.getUTCMinutes(), 2) + '-' +
|
||||||
|
zpad(now.getUTCSeconds(), 2) + '.0Z'
|
||||||
|
);
|
||||||
|
data['x-ethers'] = {
|
||||||
|
client: client,
|
||||||
|
gethFilename: ('UTC--' + timestamp + '--' + data.address),
|
||||||
|
mnemonicCounter: utils.hexlify(mnemonicIv).substring(2),
|
||||||
|
mnemonicCiphertext: utils.hexlify(mnemonicCiphertext).substring(2),
|
||||||
|
version: "0.1"
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
if (progressCallback) { progressCallback(1); }
|
||||||
|
resolve(JSON.stringify(data));
|
||||||
|
|
||||||
|
} else if (progressCallback) {
|
||||||
|
return progressCallback(progress);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
module.exports = secretStorage;
|
||||||
23
utils/sha2.js
Normal file
23
utils/sha2.js
Normal file
@ -0,0 +1,23 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var hash = require('hash.js');
|
||||||
|
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
function sha256(data) {
|
||||||
|
data = convert.arrayify(data);
|
||||||
|
return '0x' + (hash.sha256().update(data).digest('hex'));
|
||||||
|
}
|
||||||
|
|
||||||
|
function sha512(data) {
|
||||||
|
data = convert.arrayify(data);
|
||||||
|
return '0x' + (hash.sha512().update(data).digest('hex'));
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
sha256: sha256,
|
||||||
|
sha512: sha512,
|
||||||
|
|
||||||
|
createSha256: hash.sha256,
|
||||||
|
createSha512: hash.sha512,
|
||||||
|
}
|
||||||
104
utils/signing-key.js
Normal file
104
utils/signing-key.js
Normal file
@ -0,0 +1,104 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* SigningKey
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
var secp256k1 = new (require('elliptic')).ec('secp256k1');
|
||||||
|
var utils = (function() {
|
||||||
|
var convert = require('../utils/convert');
|
||||||
|
return {
|
||||||
|
defineProperty: require('../utils/properties').defineProperty,
|
||||||
|
|
||||||
|
arrayify: convert.arrayify,
|
||||||
|
hexlify: convert.hexlify,
|
||||||
|
padZeros: convert.padZeros,
|
||||||
|
|
||||||
|
getAddress: require('../utils/address').getAddress,
|
||||||
|
|
||||||
|
keccak256: require('../utils/keccak256')
|
||||||
|
};
|
||||||
|
})();
|
||||||
|
|
||||||
|
var errors = require('../utils/errors');
|
||||||
|
|
||||||
|
|
||||||
|
function SigningKey(privateKey) {
|
||||||
|
errors.checkNew(this, SigningKey);
|
||||||
|
|
||||||
|
try {
|
||||||
|
privateKey = utils.arrayify(privateKey);
|
||||||
|
if (privateKey.length !== 32) {
|
||||||
|
errors.throwError('exactly 32 bytes required', errors.INVALID_ARGUMENT, { value: privateKey });
|
||||||
|
}
|
||||||
|
} catch(error) {
|
||||||
|
var params = { arg: 'privateKey', reason: error.reason, value: '[REDACTED]' }
|
||||||
|
if (error.value) {
|
||||||
|
if(typeof(error.value.length) === 'number') {
|
||||||
|
params.length = error.value.length;
|
||||||
|
}
|
||||||
|
params.type = typeof(error.value);
|
||||||
|
}
|
||||||
|
errors.throwError('invalid private key', error.code, params);
|
||||||
|
}
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'privateKey', utils.hexlify(privateKey))
|
||||||
|
|
||||||
|
var keyPair = secp256k1.keyFromPrivate(privateKey);
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'publicKey', '0x' + keyPair.getPublic(true, 'hex'))
|
||||||
|
|
||||||
|
var address = SigningKey.publicKeyToAddress('0x' + keyPair.getPublic(false, 'hex'));
|
||||||
|
utils.defineProperty(this, 'address', address)
|
||||||
|
|
||||||
|
utils.defineProperty(this, 'signDigest', function(digest) {
|
||||||
|
var signature = keyPair.sign(utils.arrayify(digest), {canonical: true});
|
||||||
|
var r = '0x' + signature.r.toString(16);
|
||||||
|
var s = '0x' + signature.s.toString(16);
|
||||||
|
|
||||||
|
return {
|
||||||
|
recoveryParam: signature.recoveryParam,
|
||||||
|
r: utils.hexlify(utils.padZeros(r, 32)),
|
||||||
|
s: utils.hexlify(utils.padZeros(s, 32))
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
utils.defineProperty(SigningKey, 'recover', function(digest, r, s, recoveryParam) {
|
||||||
|
var signature = {
|
||||||
|
r: utils.arrayify(r),
|
||||||
|
s: utils.arrayify(s)
|
||||||
|
};
|
||||||
|
var publicKey = secp256k1.recoverPubKey(utils.arrayify(digest), signature, recoveryParam);
|
||||||
|
return SigningKey.publicKeyToAddress('0x' + publicKey.encode('hex', false));
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
utils.defineProperty(SigningKey, 'getPublicKey', function(value, compressed) {
|
||||||
|
value = utils.arrayify(value);
|
||||||
|
compressed = !!compressed;
|
||||||
|
|
||||||
|
if (value.length === 32) {
|
||||||
|
var keyPair = secp256k1.keyFromPrivate(value);
|
||||||
|
return '0x' + keyPair.getPublic(compressed, 'hex');
|
||||||
|
|
||||||
|
} else if (value.length === 33) {
|
||||||
|
var keyPair = secp256k1.keyFromPublic(value);
|
||||||
|
return '0x' + keyPair.getPublic(compressed, 'hex');
|
||||||
|
|
||||||
|
} else if (value.length === 65) {
|
||||||
|
var keyPair = secp256k1.keyFromPublic(value);
|
||||||
|
return '0x' + keyPair.getPublic(compressed, 'hex');
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new Error('invalid value');
|
||||||
|
});
|
||||||
|
|
||||||
|
utils.defineProperty(SigningKey, 'publicKeyToAddress', function(publicKey) {
|
||||||
|
publicKey = '0x' + SigningKey.getPublicKey(publicKey, false).slice(4);
|
||||||
|
return utils.getAddress('0x' + utils.keccak256(publicKey).substring(26));
|
||||||
|
});
|
||||||
|
|
||||||
|
module.exports = SigningKey;
|
||||||
97
utils/solidity.js
Normal file
97
utils/solidity.js
Normal file
@ -0,0 +1,97 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
var bigNumberify = require('./bignumber').bigNumberify;
|
||||||
|
var convert = require('./convert');
|
||||||
|
var getAddress = require('./address').getAddress;
|
||||||
|
var utf8 = require('./utf8');
|
||||||
|
|
||||||
|
var hashKeccak256 = require('./keccak256');
|
||||||
|
var hashSha256 = require('./sha2').sha256;
|
||||||
|
|
||||||
|
var regexBytes = new RegExp("^bytes([0-9]+)$");
|
||||||
|
var regexNumber = new RegExp("^(u?int)([0-9]*)$");
|
||||||
|
var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
|
||||||
|
|
||||||
|
var Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
|
||||||
|
|
||||||
|
function _pack(type, value, isArray) {
|
||||||
|
switch(type) {
|
||||||
|
case 'address':
|
||||||
|
if (isArray) { return convert.padZeros(value, 32); }
|
||||||
|
return convert.arrayify(value);
|
||||||
|
case 'string':
|
||||||
|
return utf8.toUtf8Bytes(value);
|
||||||
|
case 'bytes':
|
||||||
|
return convert.arrayify(value);
|
||||||
|
case 'bool':
|
||||||
|
value = (value ? '0x01': '0x00');
|
||||||
|
if (isArray) { return convert.padZeros(value, 32); }
|
||||||
|
return convert.arrayify(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
var match = type.match(regexNumber);
|
||||||
|
if (match) {
|
||||||
|
var signed = (match[1] === 'int')
|
||||||
|
var size = parseInt(match[2] || "256")
|
||||||
|
if ((size % 8 != 0) || size === 0 || size > 256) {
|
||||||
|
throw new Error('invalid number type - ' + type);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isArray) { size = 256; }
|
||||||
|
|
||||||
|
value = bigNumberify(value).toTwos(size);
|
||||||
|
|
||||||
|
return convert.padZeros(value, size / 8);
|
||||||
|
}
|
||||||
|
|
||||||
|
match = type.match(regexBytes);
|
||||||
|
if (match) {
|
||||||
|
var size = match[1];
|
||||||
|
if (size != parseInt(size) || size === 0 || size > 32) {
|
||||||
|
throw new Error('invalid number type - ' + type);
|
||||||
|
}
|
||||||
|
size = parseInt(size);
|
||||||
|
if (convert.arrayify(value).byteLength !== size) { throw new Error('invalid value for ' + type); }
|
||||||
|
if (isArray) { return (value + Zeros).substring(0, 66); }
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
match = type.match(regexArray);
|
||||||
|
if (match) {
|
||||||
|
var baseType = match[1];
|
||||||
|
var count = parseInt(match[2] || value.length);
|
||||||
|
if (count != value.length) { throw new Error('invalid value for ' + type); }
|
||||||
|
var result = [];
|
||||||
|
value.forEach(function(value) {
|
||||||
|
value = _pack(baseType, value, true);
|
||||||
|
result.push(value);
|
||||||
|
});
|
||||||
|
return convert.concat(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new Error('unknown type - ' + type);
|
||||||
|
}
|
||||||
|
|
||||||
|
function pack(types, values) {
|
||||||
|
if (types.length != values.length) { throw new Error('type/value count mismatch'); }
|
||||||
|
var tight = [];
|
||||||
|
types.forEach(function(type, index) {
|
||||||
|
tight.push(_pack(type, values[index]));
|
||||||
|
});
|
||||||
|
return convert.hexlify(convert.concat(tight));
|
||||||
|
}
|
||||||
|
|
||||||
|
function keccak256(types, values) {
|
||||||
|
return hashKeccak256(pack(types, values));
|
||||||
|
}
|
||||||
|
|
||||||
|
function sha256(types, values) {
|
||||||
|
return hashSha256(pack(types, values));
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
pack: pack,
|
||||||
|
|
||||||
|
keccak256: keccak256,
|
||||||
|
sha256: sha256,
|
||||||
|
}
|
||||||
11
utils/throw-error.js
Normal file
11
utils/throw-error.js
Normal file
@ -0,0 +1,11 @@
|
|||||||
|
'use strict';
|
||||||
|
|
||||||
|
function throwError(message, params) {
|
||||||
|
var error = new Error(message);
|
||||||
|
for (var key in params) {
|
||||||
|
error[key] = params[key];
|
||||||
|
}
|
||||||
|
throw error;
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = throwError;
|
||||||
148
utils/units.js
Normal file
148
utils/units.js
Normal file
@ -0,0 +1,148 @@
|
|||||||
|
var bigNumberify = require('./bignumber.js').bigNumberify;
|
||||||
|
var throwError = require('./throw-error');
|
||||||
|
|
||||||
|
var zero = new bigNumberify(0);
|
||||||
|
var negative1 = new bigNumberify(-1);
|
||||||
|
|
||||||
|
var names = [
|
||||||
|
'wei',
|
||||||
|
'kwei',
|
||||||
|
'Mwei',
|
||||||
|
'Gwei',
|
||||||
|
'szabo',
|
||||||
|
'finny',
|
||||||
|
'ether',
|
||||||
|
];
|
||||||
|
|
||||||
|
var getUnitInfo = (function() {
|
||||||
|
var unitInfos = {};
|
||||||
|
|
||||||
|
function getUnitInfo(value) {
|
||||||
|
return {
|
||||||
|
decimals: value.length - 1,
|
||||||
|
tenPower: bigNumberify(value)
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// Cache the common units
|
||||||
|
var value = '1';
|
||||||
|
names.forEach(function(name) {
|
||||||
|
var info = getUnitInfo(value);
|
||||||
|
unitInfos[name.toLowerCase()] = info;
|
||||||
|
unitInfos[String(info.decimals)] = info;
|
||||||
|
value += '000';
|
||||||
|
});
|
||||||
|
|
||||||
|
return function(name) {
|
||||||
|
// Try the cache
|
||||||
|
var info = unitInfos[String(name).toLowerCase()];
|
||||||
|
|
||||||
|
if (!info && typeof(name) === 'number' && parseInt(name) == name && name >= 0 && name <= 256) {
|
||||||
|
var value = '1';
|
||||||
|
for (var i = 0; i < name; i++) { value += '0'; }
|
||||||
|
info = getUnitInfo(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make sure we got something
|
||||||
|
if (!info) { throwError('invalid unitType', { unitType: name }); }
|
||||||
|
|
||||||
|
return info;
|
||||||
|
}
|
||||||
|
})();
|
||||||
|
|
||||||
|
function formatUnits(value, unitType, options) {
|
||||||
|
if (typeof(unitType) === 'object' && !options) {
|
||||||
|
options = unitType;
|
||||||
|
unitType = undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (unitType == null) { unitType = 18; }
|
||||||
|
var unitInfo = getUnitInfo(unitType);
|
||||||
|
|
||||||
|
// Make sure wei is a big number (convert as necessary)
|
||||||
|
value = bigNumberify(value);
|
||||||
|
|
||||||
|
if (!options) { options = {}; }
|
||||||
|
|
||||||
|
var negative = value.lt(zero);
|
||||||
|
if (negative) { value = value.mul(negative1); }
|
||||||
|
|
||||||
|
var fraction = value.mod(unitInfo.tenPower).toString(10);
|
||||||
|
while (fraction.length < unitInfo.decimals) { fraction = '0' + fraction; }
|
||||||
|
|
||||||
|
// Strip off trailing zeros (but keep one if would otherwise be bare decimal point)
|
||||||
|
if (!options.pad) {
|
||||||
|
fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
|
||||||
|
}
|
||||||
|
|
||||||
|
var whole = value.div(unitInfo.tenPower).toString(10);
|
||||||
|
|
||||||
|
if (options.commify) {
|
||||||
|
whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",")
|
||||||
|
}
|
||||||
|
|
||||||
|
var value = whole + '.' + fraction;
|
||||||
|
|
||||||
|
if (negative) { value = '-' + value; }
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
function parseUnits(value, unitType) {
|
||||||
|
if (unitType == null) { unitType = 18; }
|
||||||
|
var unitInfo = getUnitInfo(unitType);
|
||||||
|
|
||||||
|
if (typeof(value) !== 'string' || !value.match(/^-?[0-9.,]+$/)) {
|
||||||
|
throwError('invalid value', { input: value });
|
||||||
|
}
|
||||||
|
|
||||||
|
// Remove commas
|
||||||
|
var value = value.replace(/,/g,'');
|
||||||
|
|
||||||
|
// Is it negative?
|
||||||
|
var negative = (value.substring(0, 1) === '-');
|
||||||
|
if (negative) { value = value.substring(1); }
|
||||||
|
|
||||||
|
if (value === '.') { throwError('invalid value', { input: value }); }
|
||||||
|
|
||||||
|
// Split it into a whole and fractional part
|
||||||
|
var comps = value.split('.');
|
||||||
|
if (comps.length > 2) { throwError('too many decimal points', { input: value }); }
|
||||||
|
|
||||||
|
var whole = comps[0], fraction = comps[1];
|
||||||
|
if (!whole) { whole = '0'; }
|
||||||
|
if (!fraction) { fraction = '0'; }
|
||||||
|
|
||||||
|
// Prevent underflow
|
||||||
|
if (fraction.length > unitInfo.decimals) {
|
||||||
|
throwError('too many decimal places', { input: value, decimals: fraction.length });
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fully pad the string with zeros to get to wei
|
||||||
|
while (fraction.length < unitInfo.decimals) { fraction += '0'; }
|
||||||
|
|
||||||
|
whole = bigNumberify(whole);
|
||||||
|
fraction = bigNumberify(fraction);
|
||||||
|
|
||||||
|
var wei = (whole.mul(unitInfo.tenPower)).add(fraction);
|
||||||
|
|
||||||
|
if (negative) { wei = wei.mul(negative1); }
|
||||||
|
|
||||||
|
return wei;
|
||||||
|
}
|
||||||
|
|
||||||
|
function formatEther(wei, options) {
|
||||||
|
return formatUnits(wei, 18, options);
|
||||||
|
}
|
||||||
|
|
||||||
|
function parseEther(ether) {
|
||||||
|
return parseUnits(ether, 18);
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
formatEther: formatEther,
|
||||||
|
parseEther: parseEther,
|
||||||
|
|
||||||
|
formatUnits: formatUnits,
|
||||||
|
parseUnits: parseUnits,
|
||||||
|
}
|
||||||
113
utils/utf8.js
Normal file
113
utils/utf8.js
Normal file
@ -0,0 +1,113 @@
|
|||||||
|
|
||||||
|
var convert = require('./convert.js');
|
||||||
|
|
||||||
|
// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
|
||||||
|
function utf8ToBytes(str) {
|
||||||
|
var result = [];
|
||||||
|
var offset = 0;
|
||||||
|
for (var i = 0; i < str.length; i++) {
|
||||||
|
var c = str.charCodeAt(i);
|
||||||
|
if (c < 128) {
|
||||||
|
result[offset++] = c;
|
||||||
|
} else if (c < 2048) {
|
||||||
|
result[offset++] = (c >> 6) | 192;
|
||||||
|
result[offset++] = (c & 63) | 128;
|
||||||
|
} else if (((c & 0xFC00) == 0xD800) && (i + 1) < str.length && ((str.charCodeAt(i + 1) & 0xFC00) == 0xDC00)) {
|
||||||
|
// Surrogate Pair
|
||||||
|
c = 0x10000 + ((c & 0x03FF) << 10) + (str.charCodeAt(++i) & 0x03FF);
|
||||||
|
result[offset++] = (c >> 18) | 240;
|
||||||
|
result[offset++] = ((c >> 12) & 63) | 128;
|
||||||
|
result[offset++] = ((c >> 6) & 63) | 128;
|
||||||
|
result[offset++] = (c & 63) | 128;
|
||||||
|
} else {
|
||||||
|
result[offset++] = (c >> 12) | 224;
|
||||||
|
result[offset++] = ((c >> 6) & 63) | 128;
|
||||||
|
result[offset++] = (c & 63) | 128;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return convert.arrayify(result);
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499
|
||||||
|
function bytesToUtf8(bytes) {
|
||||||
|
bytes = convert.arrayify(bytes);
|
||||||
|
|
||||||
|
var result = '';
|
||||||
|
var i = 0;
|
||||||
|
|
||||||
|
// Invalid bytes are ignored
|
||||||
|
while(i < bytes.length) {
|
||||||
|
var c = bytes[i++];
|
||||||
|
if (c >> 7 == 0) {
|
||||||
|
// 0xxx xxxx
|
||||||
|
result += String.fromCharCode(c);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Invalid starting byte
|
||||||
|
if (c >> 6 == 0x02) { continue; }
|
||||||
|
|
||||||
|
// Multibyte; how many bytes left for thus character?
|
||||||
|
var extraLength = null;
|
||||||
|
if (c >> 5 == 0x06) {
|
||||||
|
extraLength = 1;
|
||||||
|
} else if (c >> 4 == 0x0e) {
|
||||||
|
extraLength = 2;
|
||||||
|
} else if (c >> 3 == 0x1e) {
|
||||||
|
extraLength = 3;
|
||||||
|
} else if (c >> 2 == 0x3e) {
|
||||||
|
extraLength = 4;
|
||||||
|
} else if (c >> 1 == 0x7e) {
|
||||||
|
extraLength = 5;
|
||||||
|
} else {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Do we have enough bytes in our data?
|
||||||
|
if (i + extraLength > bytes.length) {
|
||||||
|
|
||||||
|
// If there is an invalid unprocessed byte, try to continue
|
||||||
|
for (; i < bytes.length; i++) {
|
||||||
|
if (bytes[i] >> 6 != 0x02) { break; }
|
||||||
|
}
|
||||||
|
if (i != bytes.length) continue;
|
||||||
|
|
||||||
|
// All leftover bytes are valid.
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Remove the UTF-8 prefix from the char (res)
|
||||||
|
var res = c & ((1 << (8 - extraLength - 1)) - 1);
|
||||||
|
|
||||||
|
var count;
|
||||||
|
for (count = 0; count < extraLength; count++) {
|
||||||
|
var nextChar = bytes[i++];
|
||||||
|
|
||||||
|
// Is the char valid multibyte part?
|
||||||
|
if (nextChar >> 6 != 0x02) {break;};
|
||||||
|
res = (res << 6) | (nextChar & 0x3f);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (count != extraLength) {
|
||||||
|
i--;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (res <= 0xffff) {
|
||||||
|
result += String.fromCharCode(res);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
res -= 0x10000;
|
||||||
|
result += String.fromCharCode(((res >> 10) & 0x3ff) + 0xd800, (res & 0x3ff) + 0xdc00);
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
toUtf8Bytes: utf8ToBytes,
|
||||||
|
toUtf8String: bytesToUtf8,
|
||||||
|
};
|
||||||
1
utils/words.json
Normal file
1
utils/words.json
Normal file
File diff suppressed because one or more lines are too long
Loading…
Reference in New Issue
Block a user