ptokens-peosio-token
Version:
repo holding the code for interacting with pEosioToken
375 lines (368 loc) • 18.2 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var _asyncToGenerator = _interopDefault(require('@babel/runtime/helpers/asyncToGenerator'));
var _classCallCheck = _interopDefault(require('@babel/runtime/helpers/classCallCheck'));
var _createClass = _interopDefault(require('@babel/runtime/helpers/createClass'));
var _inherits = _interopDefault(require('@babel/runtime/helpers/inherits'));
var _possibleConstructorReturn = _interopDefault(require('@babel/runtime/helpers/possibleConstructorReturn'));
var _getPrototypeOf = _interopDefault(require('@babel/runtime/helpers/getPrototypeOf'));
var _regeneratorRuntime = _interopDefault(require('@babel/runtime/regenerator'));
var Web3 = _interopDefault(require('web3'));
var Web3PromiEvent = _interopDefault(require('web3-core-promievent'));
var ptokensNodeSelector = require('ptokens-node-selector');
var ptokensUtils = require('ptokens-utils');
var BigNumber = _interopDefault(require('bignumber.js'));
var Web3Utils = _interopDefault(require('web3-utils'));
var _defineProperty = _interopDefault(require('@babel/runtime/helpers/defineProperty'));
var _constants$pTokens$pE;
var minimumAmounts = (_constants$pTokens$pE = {}, _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.pEOS, {
issue: 0.0001,
redeem: 1000000000
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.IQ, {
issue: 0.001,
redeem: 1000000000
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.TLOS, {
issue: 0.0001,
redeem: 1000000000
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.EFX, {
issue: 0.001,
redeem: 1000000000
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.pSEEDS, {
issue: 0.0001,
redeem: 1000000000
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.NUCO, {
issue: 1,
redeem: 1
}), _defineProperty(_constants$pTokens$pE, ptokensUtils.constants.pTokens.ORE, {
issue: 0.0001,
redeem: 1000000000
}), _constants$pTokens$pE);
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
var pEosioToken = function (_NodeSelector) {
_inherits(pEosioToken, _NodeSelector);
var _super = _createSuper(pEosioToken);
function pEosioToken(_configs) {
var _this;
_classCallCheck(this, pEosioToken);
var _helpers$parseParams = ptokensUtils.helpers.parseParams(_configs, ptokensUtils.constants.blockchains.Eosio),
hostBlockchain = _helpers$parseParams.hostBlockchain,
hostNetwork = _helpers$parseParams.hostNetwork,
nativeBlockchain = _helpers$parseParams.nativeBlockchain,
nativeNetwork = _helpers$parseParams.nativeNetwork;
_this = _super.call(this, {
pToken: _configs.pToken,
hostBlockchain: hostBlockchain,
hostNetwork: hostNetwork,
nativeBlockchain: nativeBlockchain,
nativeNetwork: nativeNetwork,
defaultNode: _configs.defaultNode
});
var ethPrivateKey = _configs.ethPrivateKey,
ethProvider = _configs.ethProvider,
bscPrivateKey = _configs.bscPrivateKey,
bscProvider = _configs.bscProvider,
eosPrivateKey = _configs.eosPrivateKey,
eosRpc = _configs.eosRpc,
eosSignatureProvider = _configs.eosSignatureProvider,
telosPrivateKey = _configs.telosPrivateKey,
telosRpc = _configs.telosRpc,
telosSignatureProvider = _configs.telosSignatureProvider,
orePrivateKey = _configs.orePrivateKey,
oreRpc = _configs.oreRpc,
oreSignatureProvider = _configs.oreSignatureProvider;
if (eosSignatureProvider) {
_this.nativeApi = ptokensUtils.eos.getApi(null, eosRpc, eosSignatureProvider);
} else if (eosPrivateKey && eosRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(eosPrivateKey, eosRpc, null);
_this.nativePrivateKey = eosPrivateKey;
} else if (!eosSignatureProvider && !eosPrivateKey && eosRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(null, eosRpc, null);
}
if (telosSignatureProvider) {
_this.nativeApi = ptokensUtils.eos.getApi(null, telosRpc, telosSignatureProvider);
} else if (telosPrivateKey && telosRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(telosPrivateKey, telosRpc, null);
_this.nativePrivateKey = telosPrivateKey;
} else if (!telosSignatureProvider && !telosPrivateKey && telosRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(null, telosRpc, null);
}
if (oreSignatureProvider) {
_this.nativeApi = ptokensUtils.eos.getApi(null, oreRpc, oreSignatureProvider);
} else if (orePrivateKey && oreRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(orePrivateKey, oreRpc, null);
_this.nativePrivateKey = orePrivateKey;
} else if (!oreSignatureProvider && !orePrivateKey && oreRpc) {
_this.nativeApi = ptokensUtils.eos.getApi(null, oreRpc, null);
}
if (ethProvider) _this.hostApi = new Web3(ethProvider);
if (ethPrivateKey) {
var account = _this.hostApi.eth.accounts.privateKeyToAccount(ptokensUtils.eth.addHexPrefix(ethPrivateKey));
_this.hostApi.eth.defaultAccount = account.address;
_this.hostPrivateKey = ptokensUtils.eth.addHexPrefix(ethPrivateKey);
} else {
_this.hostPrivateKey = null;
}
if (bscProvider) _this.hostApi = new Web3(bscProvider);
if (bscPrivateKey) {
var _account2 = _this.hostApi.eth.accounts.privateKeyToAccount(ptokensUtils.eth.addHexPrefix(bscPrivateKey));
_this.hostApi.eth.defaultAccount = _account2.address;
_this.hostPrivateKey = ptokensUtils.eth.addHexPrefix(bscPrivateKey);
} else {
_this.hostPrivateKey = null;
}
return _this;
}
_createClass(pEosioToken, [{
key: "issue",
value: function issue(_amount, _hostAccount, _options) {
var _this2 = this;
var promiEvent = Web3PromiEvent();
var start = function () {
var _ref = _asyncToGenerator( _regeneratorRuntime.mark(function _callee() {
var blocksBehind, expireSeconds, permission, actor, nativeTxReceipt, _yield$_this2$selecte, broadcast_tx_hash, hostTxReceipt;
return _regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.prev = 0;
blocksBehind = _options.blocksBehind, expireSeconds = _options.expireSeconds, permission = _options.permission, actor = _options.actor;
_context.next = 4;
return _this2._loadData();
case 4:
if (!BigNumber(_amount).isLessThan(minimumAmounts[_this2.pToken.toLowerCase()].issue)) {
_context.next = 7;
break;
}
promiEvent.reject("Impossible to issue less than ".concat(minimumAmounts[_this2.pToken.toLowerCase()].issue));
return _context.abrupt("return");
case 7:
if (!((_this2.hostBlockchain === ptokensUtils.constants.blockchains.Ethereum || _this2.hostBlockchain === ptokensUtils.constants.blockchains.BinanceSmartChain) && !Web3Utils.isAddress(_hostAccount))) {
_context.next = 10;
break;
}
promiEvent.reject('Invalid host account');
return _context.abrupt("return");
case 10:
if (_this2.selectedNode) {
_context.next = 13;
break;
}
_context.next = 13;
return _this2.select();
case 13:
_this2.nativeApi.cachedAbis.set(_this2.nativeContractAddress, {
abi: ptokensUtils.abi.EosioToken,
rawAbi: null
});
_context.next = 16;
return _this2.nativeApi.transact({
actions: [{
account: _this2.nativeContractAddress,
name: 'transfer',
authorization: [{
actor: actor,
permission: permission
}],
data: {
from: actor,
to: _this2.nativeVaultAddress,
quantity: ptokensUtils.eos.getAmountInEosFormat(_amount, _this2.pToken === ptokensUtils.constants.pTokens.IQ ? 3 : 4, _this2.pToken === ptokensUtils.constants.pTokens.IQ || _this2.pToken === ptokensUtils.constants.pTokens.TLOS || _this2.pToken === ptokensUtils.constants.pTokens.EFX ? _this2.pToken.toUpperCase() : _this2.pToken.slice(1).toUpperCase()),
memo: _hostAccount
}
}]
}, {
blocksBehind: blocksBehind,
expireSeconds: expireSeconds
});
case 16:
nativeTxReceipt = _context.sent;
promiEvent.eventEmitter.emit('nativeTxConfirmed', nativeTxReceipt);
_context.next = 20;
return _this2.selectedNode.monitorIncomingTransaction(nativeTxReceipt.transaction_id, promiEvent.eventEmitter);
case 20:
_yield$_this2$selecte = _context.sent;
broadcast_tx_hash = _yield$_this2$selecte.broadcast_tx_hash;
_context.next = 24;
return ptokensUtils.eth.waitForTransactionConfirmation(_this2.hostApi, broadcast_tx_hash);
case 24:
hostTxReceipt = _context.sent;
promiEvent.eventEmitter.emit('hostTxConfirmed', hostTxReceipt);
promiEvent.resolve({
to: _hostAccount,
nativeTx: nativeTxReceipt.transaction_id,
hostTx: broadcast_tx_hash,
amount: _amount
});
_context.next = 32;
break;
case 29:
_context.prev = 29;
_context.t0 = _context["catch"](0);
promiEvent.reject(_context.t0);
case 32:
case "end":
return _context.stop();
}
}
}, _callee, null, [[0, 29]]);
}));
return function start() {
return _ref.apply(this, arguments);
};
}();
start();
return promiEvent.eventEmitter;
}
}, {
key: "redeemWithMetadata",
value: function redeemWithMetadata(_amount, _account, _metadata) {
var _options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
return this._redeem(_amount, _account, _metadata, _options);
}
}, {
key: "redeem",
value: function redeem(_amount, _account) {
var _options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
return this._redeem(_amount, _account, null, _options);
}
}, {
key: "_redeem",
value: function _redeem(_amount, _account, _metadata) {
var _this3 = this;
var _options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
var promiEvent = Web3PromiEvent();
var gas = _options.gas,
gasPrice = _options.gasPrice;
var start = function () {
var _ref2 = _asyncToGenerator( _regeneratorRuntime.mark(function _callee2() {
var hostTxHash, hostTxReceipt, incomingTxReport, nativeTxReceipt;
return _regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.prev = 0;
_context2.next = 3;
return _this3._loadData();
case 3:
if (!BigNumber(_amount).isLessThan(minimumAmounts[_this3.pToken.toLowerCase()].redeem)) {
_context2.next = 6;
break;
}
promiEvent.reject("Impossible to redeem less than ".concat(minimumAmounts[_this3.pToken.toLowerCase()].redeem));
return _context2.abrupt("return");
case 6:
if (ptokensUtils.eos.isValidAccountName(_account)) {
_context2.next = 9;
break;
}
promiEvent.reject('Invalid native account');
return _context2.abrupt("return");
case 9:
hostTxHash = null;
if (!(_this3.hostBlockchain === ptokensUtils.constants.blockchains.Ethereum || _this3.hostBlockchain === ptokensUtils.constants.blockchains.Polygon || _this3.hostBlockchain === ptokensUtils.constants.blockchains.BinanceSmartChain)) {
_context2.next = 16;
break;
}
_context2.next = 13;
return ptokensUtils.redeemFrom.redeemFromEvmCompatible(_this3.hostApi, {
privateKey: _this3.hostPrivateKey,
gas: gas,
gasPrice: gasPrice,
contractAddress: _this3.hostContractAddress,
value: 0
}, _metadata ? [_amount, _metadata, _account] : [_amount, _account], promiEvent, 'hostTxBroadcasted');
case 13:
hostTxReceipt = _context2.sent;
promiEvent.eventEmitter.emit('hostTxConfirmed', hostTxReceipt);
hostTxHash = hostTxReceipt.transactionHash;
case 16:
_context2.next = 18;
return _this3.selectedNode.monitorIncomingTransaction(hostTxHash, promiEvent.eventEmitter);
case 18:
incomingTxReport = _context2.sent;
_context2.next = 21;
return ptokensUtils.eos.waitForTransactionConfirmation(_this3.nativeApi, incomingTxReport.broadcast_tx_hash);
case 21:
nativeTxReceipt = _context2.sent;
promiEvent.eventEmitter.emit('nativeTxConfirmed', nativeTxReceipt);
promiEvent.resolve({
to: _account,
nativeTx: nativeTxReceipt.transaction_id,
hostTx: hostTxHash,
amount: BigNumber(_amount).toFixed()
});
_context2.next = 29;
break;
case 26:
_context2.prev = 26;
_context2.t0 = _context2["catch"](0);
promiEvent.reject(_context2.t0);
case 29:
case "end":
return _context2.stop();
}
}
}, _callee2, null, [[0, 26]]);
}));
return function start() {
return _ref2.apply(this, arguments);
};
}();
start();
return promiEvent.eventEmitter;
}
}, {
key: "_loadData",
value: function () {
var _loadData2 = _asyncToGenerator( _regeneratorRuntime.mark(function _callee3() {
var _yield$this$selectedN, native_smart_contract_address, host_smart_contract_address, native_vault_address;
return _regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
_context3.prev = 0;
if (this.selectedNode) {
_context3.next = 4;
break;
}
_context3.next = 4;
return this.select();
case 4:
if (!(!this.nativeContractAddress || !this.hostContractAddress)) {
_context3.next = 14;
break;
}
_context3.next = 7;
return this.selectedNode.getInfo();
case 7:
_yield$this$selectedN = _context3.sent;
native_smart_contract_address = _yield$this$selectedN.native_smart_contract_address;
host_smart_contract_address = _yield$this$selectedN.host_smart_contract_address;
native_vault_address = _yield$this$selectedN.native_vault_address;
this.nativeVaultAddress = native_vault_address;
this.nativeContractAddress = native_smart_contract_address;
this.hostContractAddress = this.hostBlockchain === ptokensUtils.constants.blockchains.Ethereum ? ptokensUtils.eth.addHexPrefix(host_smart_contract_address) : host_smart_contract_address;
case 14:
return _context3.abrupt("return", this.nativeContractAddress);
case 17:
_context3.prev = 17;
_context3.t0 = _context3["catch"](0);
throw new Error("Error during loading data: ".concat(_context3.t0.message));
case 20:
case "end":
return _context3.stop();
}
}
}, _callee3, this, [[0, 17]]);
}));
function _loadData() {
return _loadData2.apply(this, arguments);
}
return _loadData;
}()
}]);
return pEosioToken;
}(ptokensNodeSelector.NodeSelector);
exports.pEosioToken = pEosioToken;