nerve-sdk-js
Version:
nerve nerve-js nerve-sdk nerve-js-sdk
496 lines (426 loc) • 16.8 kB
JavaScript
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
var {
RPC_URL,
Minus
} = require('./htgConfig');
var ethers = require('ethers');
var CROSS_OUT_ABI = ["crossOut(string to, uint256 amount, address ERC20) public payable returns (bool)"];
var ERC20_ABI = ["transfer(address to, uint value) external returns (bool)", "allowance(address owner, address spender) external view returns (uint256)", "approve(address spender, uint256 amount) external returns (bool)"]; //验证交易参数
function validate(_x, _x2) {
return _validate.apply(this, arguments);
}
function _validate() {
_validate = _asyncToGenerator(function* (provider, tx) {
try {
var result = yield provider.call(tx);
return ethers.utils.toUtf8String('0x' + result.substr(138));
} catch (e) {
return e.toString();
}
});
return _validate.apply(this, arguments);
}
function sendTransaction(_x3, _x4, _x5) {
return _sendTransaction.apply(this, arguments);
}
function _sendTransaction() {
_sendTransaction = _asyncToGenerator(function* (pri, provider, transactionParameters) {
/* provider.listAccounts().then((accounts) => {
console.log(accounts,'====accounts====');
}); */
var wallet = new ethers.Wallet(pri, provider);
try {
var tx = yield wallet.sendTransaction(transactionParameters);
if (tx.hash) {
return {
success: true,
msg: tx.hash
};
}
} catch (e) {
return {
success: false,
msg: e
};
}
});
return _sendTransaction.apply(this, arguments);
}
module.exports = {
/**
*获取provider
* @param chain
* @param isMetaMask
*/
getProvider(chain, HTGNET) {
if (chain === 'ETH') {
//异构网络信息 测试网:ropsten, 主网:homestead
if (HTGNET === 'test') {
HTGNET = 'ropsten';
} else if (HTGNET === 'main') {
HTGNET = 'homestead';
}
return ethers.getDefaultProvider(HTGNET);
} else {
return new ethers.providers.JsonRpcProvider(RPC_URL[chain][HTGNET]);
}
},
validateAddress(account) {
try {
ethers.utils.getAddress(account);
return true;
} catch (error) {
console.error("地址校验失败: " + error);
}
return false;
},
/**
*获取eth余额
* @param ethers
* @param provider
* @param address
*/
getEthBalance(provider, address) {
var balancePromise = provider.getBalance(address);
return balancePromise.then(balance => {
return ethers.utils.formatEther(balance);
}).catch(e => {
console.error('获取ETH余额失败' + e);
});
},
/**
* ERC20合约余额
* @param provider
* @param erc20BalanceAbiFragment
* @param erc20Address ERC20合约地址
* @param tokenDecimals token小数位数
* @param address 账户
*/
getERC20Balance(provider, erc20BalanceAbiFragment, erc20Address, tokenDecimals, address) {
var contract = new ethers.Contract(erc20Address, erc20BalanceAbiFragment, provider);
var balancePromise = contract.balanceOf(address);
return balancePromise.then(balance => {
return ethers.utils.formatUnits(balance, tokenDecimals);
}).catch(e => {
console.error('获取ERC20余额失败' + e);
});
},
/**
* 获取ETH交易手续费
* @param provider
* @param gasLimit
*/
getGasPrice(provider, gasLimit) {
return provider.getGasPrice().then(gasPrice => {
return ethers.utils.formatEther(gasPrice.mul(gasLimit).toString()).toString();
});
},
/**
* 获取加速的手续费
* @param provider
* @param gasLimit
*/
getSpeedUpFee(provider, gasLimit) {
return _asyncToGenerator(function* () {
var gasPrice = yield getSpeedUpGasPrice(provider);
return ethers.utils.formatEther(gasPrice.mul(gasLimit).toString()).toString();
})();
},
/**
* 加速 GasPrice
* @param provider
*/
getSpeedUpGasPrice(provider) {
var GWEI_10 = ethers.utils.parseUnits('10', 9);
return provider.getGasPrice().then(gasPrice => {
return gasPrice.add(GWEI_10);
});
},
/**
* 获取ETH 交易nonce
* @param provider
* @param address 钱包地址
*/
getNonce(provider, address) {
return provider.getTransactionCount(address).then(transactionCount => {
return transactionCount;
});
},
getEthBlockNumber(provider) {
var blockNumberPromise = provider.getBlockNumber();
return blockNumberPromise.then(blockNumber => {
return blockNumber;
});
},
/**
* 查询账户erc20资产是否需要授权额度
* @param provider
* @param contractAddress ERC20合约地址
* @param multySignAddress 多签地址
* @param fromAddress from地址
*/
isNeedApprovedERC20(provider, contractAddress, multySignAddress, fromAddress) {
var contract = new ethers.Contract(contractAddress, ERC20_ABI, provider);
var allowancePromise = contract.allowance(fromAddress, multySignAddress);
return allowancePromise.then(allowance => {
var baseAllowance = '100000000000000000000000000000000000000000000000000000000000000000000000000000'; // console.log(Minus(baseAllowance, allowance).toString())
//已授权额度小于baseAllowance，则需要授权
return Minus(baseAllowance, allowance) >= 0;
}).catch(e => {
console.error('获取erc20资产授权额度失败' + e);
return true;
});
},
/**
* 授权erc20额度
* @param pri 账户私钥
* @param fromAddress from地址
* @param provider
* @param contractAddress ERC20合约地址
* @param multySignAddress 多签地址
*/
approveERC20(pri, fromAddress, provider, contractAddress, multySignAddress) {
return _asyncToGenerator(function* () {
var iface = new ethers.utils.Interface(ERC20_ABI);
var data = iface.functions.approve.encode([multySignAddress, new ethers.utils.BigNumber('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')]);
var transactionParameters = {
to: contractAddress,
from: fromAddress,
value: '0x00',
data: data
};
var failed = yield validate(provider, transactionParameters);
if (failed) {
console.error('failed approveERC20' + failed);
return {
success: false,
msg: 'failed approveERC20' + failed
};
}
delete transactionParameters.from; //etherjs 4.0 from参数无效 报错
return sendTransaction(pri, provider, transactionParameters);
})();
},
/**
* 跨链转入ETH
* @param pri 账户私钥
* @param fromAddress from地址
* @param provider
* @param multySignAddress 多签地址
* @param toAddress 接收地址(Nerve网络地址)
* @param numbers 交易数量
*/
sendETH(pri, fromAddress, provider, multySignAddress, toAddress, numbers) {
return _asyncToGenerator(function* () {
var amount = ethers.utils.parseEther(numbers);
var iface = new ethers.utils.Interface(CROSS_OUT_ABI);
var data = iface.functions.crossOut.encode([toAddress, amount, '0x0000000000000000000000000000000000000000']);
var transactionParameters = {
from: fromAddress,
to: multySignAddress,
value: amount,
data: data
};
var failed = yield validate(provider, transactionParameters);
if (failed) {
console.error('failed approveERC20' + failed);
return {
success: false,
msg: 'failed approveERC20' + failed
};
}
delete transactionParameters.from;
return sendTransaction(pri, provider, transactionParameters);
})();
},
/**
* 跨链转入erc20资产
* @param pri 账户私钥
* @param fromAddress from地址
* @param provider
* @param contractAddress ERC20合约地址
* @param multySignAddress 多签地址
* @param toAddress 接收地址(Nerve网络地址)
* @param decimals token精度
* @param numbers 交易数量
*/
sendERC20(pri, fromAddress, provider, contractAddress, multySignAddress, toAddress, decimals, numbers) {
return _asyncToGenerator(function* () {
var numberOfTokens = ethers.utils.parseUnits(numbers, decimals);
var iface = new ethers.utils.Interface(CROSS_OUT_ABI);
var data = iface.functions.crossOut.encode([toAddress, numberOfTokens, contractAddress]);
var transactionParameters = {
to: multySignAddress,
from: fromAddress,
//验证合约调用需要from,必传
value: '0x00',
data: data
};
var failed = yield validate(provider, transactionParameters);
if (failed) {
console.error('failed sendERC20' + failed);
return {
success: false,
msg: 'failed sendERC20' + failed
};
}
delete transactionParameters.from; //etherjs 4.0 from参数无效 报错
return sendTransaction(pri, provider, transactionParameters);
})();
},
transferERC20(pri, fromAddress, provider, contractAddress, toAddress, decimals, numbers) {
return _asyncToGenerator(function* () {
var numberOfTokens = ethers.utils.parseUnits(numbers, decimals);
var iface = new ethers.utils.Interface(ERC20_ABI);
var data = iface.functions.transfer.encode([toAddress, numberOfTokens]);
var transactionParameters = {
to: contractAddress,
from: fromAddress,
//验证合约调用需要from,必传
value: '0x00',
data: data
};
var failed = yield validate(provider, transactionParameters);
if (failed) {
console.error('failed transferERC20' + failed);
return {
success: false,
msg: 'failed transferERC20' + failed
};
}
delete transactionParameters.from; //etherjs 4.0 from参数无效 报错
var gasPrice = yield getWithdrawGas(provider);
transactionParameters.gasLimit = 150000; //todo 是否加速，是则乘以加速系数
transactionParameters.gasPrice = gasPrice;
return sendTransaction(pri, provider, transactionParameters);
})();
},
/**
* 提现默认手续费
* @param provider
* @param otherMainAssetCoin 手续费资产信息 eg. {chainId: 5, assetId: 1, decimals: 8}
* @param otherMainAssetUSD 手续费资产的USDT价格
* @param currentMainAssetUSD 当前提现异构链网络主资产的USDT价格
* @param isToken 是否token资产
*/
calcOtherMainAssetOfWithdrawTest(provider, otherMainAssetCoin, otherMainAssetUSD, currentMainAssetUSD, isToken) {
var _this = this;
return _asyncToGenerator(function* () {
// const gasPrice = new ethers.utils.BigNumber('5000000000');
var gasPrice = yield _this.getWithdrawGas(provider);
console.log(ethers.utils.formatUnits(gasPrice, 9), 'gasPrice');
var result = _this.calcOtherMainAssetOfWithdraw(otherMainAssetCoin, otherMainAssetUSD, gasPrice, currentMainAssetUSD, isToken);
return result;
})();
},
getWithdrawGas(provider) {
return _asyncToGenerator(function* () {
return provider.getGasPrice().then(gasPrice => {
return gasPrice;
});
})();
},
/**
* @param otherMainAssetCoin 手续费资产信息 eg. {chainId: 5, assetId: 1, decimals: 8}
* @param otherMainAssetUSD 手续费资产的USDT价格
* @param gasPrice 当前异构网络的平均gas价格
* @param currentMainAssetUSD 当前提现异构链网络主资产的USDT价格
* @param isToken 是否token资产
*/
calcOtherMainAssetOfWithdraw(otherMainAssetCoin, otherMainAssetUSD, gasPrice, currentMainAssetUSD, isToken) {
var gasLimit;
if (isToken) {
gasLimit = new ethers.utils.BigNumber('210000');
} else {
gasLimit = new ethers.utils.BigNumber('190000');
}
gasLimit = '252000';
console.log(gasLimit.toString(), 'gasLimit');
var otherMainAssetUSDBig = ethers.utils.parseUnits(otherMainAssetUSD.toString(), 18);
var currentMainAssetUSDBig = ethers.utils.parseUnits(currentMainAssetUSD.toString(), 18);
var result = currentMainAssetUSDBig.mul(gasPrice).mul(gasLimit).mul(ethers.utils.parseUnits('1', otherMainAssetCoin.decimals)).div(ethers.utils.parseUnits('1', 18)).div(otherMainAssetUSDBig); // 当NVT作为手续费时，向上取整
if (otherMainAssetCoin.assetId === 1) {
var numberStr = ethers.utils.formatUnits(result, otherMainAssetCoin.decimals);
var ceil = Math.ceil(numberStr);
result = ethers.utils.parseUnits(ceil.toString(), otherMainAssetCoin.decimals).toString();
}
return result;
},
calcOtherMainAssetOfWithdrawForTRX(otherMainAssetCoin, otherMainAssetUSD, currentMainAssetUSD, feeLimit) {
var otherMainAssetUSDBig = ethers.utils.parseUnits(otherMainAssetUSD.toString(), 18);
var currentMainAssetUSDBig = ethers.utils.parseUnits(currentMainAssetUSD.toString(), 18);
var result = currentMainAssetUSDBig.mul(feeLimit).mul(ethers.utils.parseUnits('1', otherMainAssetCoin.decimals)).div(ethers.utils.parseUnits('1', 6)).div(otherMainAssetUSDBig); // 当NVT作为手续费时，向上取整
if (otherMainAssetCoin.assetId === 1) {
var numberStr = ethers.utils.formatUnits(result, otherMainAssetCoin.decimals);
var ceil = Math.ceil(numberStr);
result = ethers.utils.parseUnits(ceil.toString(), otherMainAssetCoin.decimals).toString();
}
return result;
},
calcMainAssetOfWithdrawProtocol15Test(provider, isToken) {
var _this2 = this;
return _asyncToGenerator(function* () {
var gasPrice = yield _this2.getWithdrawGas(provider);
return _this2.calcMainAssetOfWithdrawProtocol15(gasPrice, isToken);
})();
},
calcMainAssetOfWithdrawProtocol15(gasPrice, isToken) {
var gasLimit;
if (isToken) {
gasLimit = new ethers.utils.BigNumber('210000');
} else {
gasLimit = new ethers.utils.BigNumber('190000');
}
return gasPrice.mul(gasLimit);
},
/**
* 计算提现默认手续费--eth/bnb
*/
calDefaultETHOfWithdrawTest(provider, isToken) {
return _asyncToGenerator(function* () {
// 获取当前以太坊网络的gasPrice
var gasPrice = yield getWithdrawGas(provider);
var result = calDefaultETHOfWithdraw(gasPrice, isToken);
return result;
})();
},
/**
* @param gasPrice 当前异构网络的平均gas价格
* @param isToken 是否token资产
*/
calDefaultETHOfWithdraw(gasPrice, isToken) {
var gasLimit;
if (isToken) {
gasLimit = new ethers.utils.BigNumber('210000');
} else {
gasLimit = new ethers.utils.BigNumber('190000');
}
var result = gasLimit.mul(gasPrice);
var finalResult = ethers.utils.formatEther(result); // console.log('finalResult: ' + finalResult);
return finalResult.toString();
},
/**
* 根据异构网币种金额换算nvt金额
* @param nvtUSD nvt的USDT价格
* @param number 异构链币种数量
* @param heterogeneousChainUSD 异构链币种的USDT价格
*/
calNvtByEth(nvtUSD, number, heterogeneousChainUSD) {
var ethAmount = ethers.utils.parseEther(number); // console.log('ethAmount: ' + ethAmount.toString());
var nvtUSDBig = ethers.utils.parseUnits(nvtUSD, 6);
var ethUSDBig = ethers.utils.parseUnits(heterogeneousChainUSD, 6);
var result = ethAmount.mul(ethUSDBig).div(ethers.utils.parseUnits(nvtUSDBig.toString(), 10)); // console.log('result: ' + result.toString());
// console.log('result format: ' + ethers.utils.formatUnits(result, 8));
var numberStr = ethers.utils.formatUnits(result, 8).toString();
var ceil = Math.ceil(numberStr); // console.log('ceil: ' + ceil);
var finalResult = ethers.utils.parseUnits(ceil.toString(), 8); // console.log('finalResult: ' + finalResult);
return finalResult.toString();
},
formatNVT(amount) {
return ethers.utils.formatUnits(amount, 8).toString();
},
formatOtherMainAsset(amount, otherMainAssetCoin) {
return ethers.utils.formatUnits(amount, otherMainAssetCoin.decimals).toString();
}
};