@cityofzion/neon-js
Version:
Neon-JS SDK for interacting with NEO blockchain
1,201 lines (1,057 loc) • 1.02 MB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 70);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, "rpc", function() { return /* reexport */ rpc_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "sc", function() { return /* reexport */ sc_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "tx", function() { return /* reexport */ tx_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "wallet", function() { return /* reexport */ wallet_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "u", function() { return /* reexport */ u_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "CONST", function() { return /* reexport */ consts_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "settings", function() { return /* reexport */ settings_namespaceObject; });
__webpack_require__.d(__webpack_exports__, "logging", function() { return /* reexport */ logging_namespaceObject; });
// NAMESPACE OBJECT: ../neon-core/lib/consts.js
var consts_namespaceObject = {};
__webpack_require__.r(consts_namespaceObject);
__webpack_require__.d(consts_namespaceObject, "ADDR_VERSION", function() { return ADDR_VERSION; });
__webpack_require__.d(consts_namespaceObject, "ASSETS", function() { return ASSETS; });
__webpack_require__.d(consts_namespaceObject, "ASSET_ID", function() { return ASSET_ID; });
__webpack_require__.d(consts_namespaceObject, "ASSET_TYPE", function() { return ASSET_TYPE; });
__webpack_require__.d(consts_namespaceObject, "CONTRACTS", function() { return CONTRACTS; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_RPC", function() { return DEFAULT_RPC; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_REQ", function() { return DEFAULT_REQ; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_SCRYPT", function() { return DEFAULT_SCRYPT; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_SYSFEE", function() { return DEFAULT_SYSFEE; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_WALLET", function() { return DEFAULT_WALLET; });
__webpack_require__.d(consts_namespaceObject, "DEFAULT_ACCOUNT_CONTRACT", function() { return DEFAULT_ACCOUNT_CONTRACT; });
__webpack_require__.d(consts_namespaceObject, "NEO_NETWORK", function() { return NEO_NETWORK; });
__webpack_require__.d(consts_namespaceObject, "NEP_HEADER", function() { return NEP_HEADER; });
__webpack_require__.d(consts_namespaceObject, "NEP_FLAG", function() { return NEP_FLAG; });
__webpack_require__.d(consts_namespaceObject, "RPC_VERSION", function() { return RPC_VERSION; });
__webpack_require__.d(consts_namespaceObject, "TX_VERSION", function() { return TX_VERSION; });
// NAMESPACE OBJECT: ../neon-core/lib/logging.js
var logging_namespaceObject = {};
__webpack_require__.r(logging_namespaceObject);
__webpack_require__.d(logging_namespaceObject, "setAll", function() { return setAll; });
__webpack_require__.d(logging_namespaceObject, "default", function() { return logging; });
__webpack_require__.d(logging_namespaceObject, "logger", function() { return logger; });
// NAMESPACE OBJECT: ../neon-core/lib/u/index.js
var u_namespaceObject = {};
__webpack_require__.r(u_namespaceObject);
__webpack_require__.d(u_namespaceObject, "isHex", function() { return isHex; });
__webpack_require__.d(u_namespaceObject, "ensureHex", function() { return ensureHex; });
__webpack_require__.d(u_namespaceObject, "hexXor", function() { return hexXor; });
__webpack_require__.d(u_namespaceObject, "reverseArray", function() { return reverseArray; });
__webpack_require__.d(u_namespaceObject, "reverseHex", function() { return reverseHex; });
__webpack_require__.d(u_namespaceObject, "ab2str", function() { return ab2str; });
__webpack_require__.d(u_namespaceObject, "str2ab", function() { return str2ab; });
__webpack_require__.d(u_namespaceObject, "hexstring2ab", function() { return hexstring2ab; });
__webpack_require__.d(u_namespaceObject, "ab2hexstring", function() { return ab2hexstring; });
__webpack_require__.d(u_namespaceObject, "str2hexstring", function() { return str2hexstring; });
__webpack_require__.d(u_namespaceObject, "hexstring2str", function() { return hexstring2str; });
__webpack_require__.d(u_namespaceObject, "int2hex", function() { return int2hex; });
__webpack_require__.d(u_namespaceObject, "num2hexstring", function() { return num2hexstring; });
__webpack_require__.d(u_namespaceObject, "num2fixed8", function() { return num2fixed8; });
__webpack_require__.d(u_namespaceObject, "fixed82num", function() { return fixed82num; });
__webpack_require__.d(u_namespaceObject, "num2VarInt", function() { return num2VarInt; });
__webpack_require__.d(u_namespaceObject, "sha256", function() { return hash_sha256; });
__webpack_require__.d(u_namespaceObject, "ripemd160", function() { return hash_ripemd160; });
__webpack_require__.d(u_namespaceObject, "hash160", function() { return hash160; });
__webpack_require__.d(u_namespaceObject, "hash256", function() { return hash256; });
__webpack_require__.d(u_namespaceObject, "Fixed8", function() { return Fixed8_Fixed8; });
__webpack_require__.d(u_namespaceObject, "StringStream", function() { return StringStream_StringStream; });
__webpack_require__.d(u_namespaceObject, "generateRandomArray", function() { return generateRandomArray; });
// NAMESPACE OBJECT: ../neon-core/lib/sc/index.js
var sc_namespaceObject = {};
__webpack_require__.r(sc_namespaceObject);
__webpack_require__.d(sc_namespaceObject, "ContractParamType", function() { return ContractParamType; });
__webpack_require__.d(sc_namespaceObject, "ContractParam", function() { return ContractParam_ContractParam; });
__webpack_require__.d(sc_namespaceObject, "likeContractParam", function() { return likeContractParam; });
__webpack_require__.d(sc_namespaceObject, "createScript", function() { return createScript; });
__webpack_require__.d(sc_namespaceObject, "generateDeployScript", function() { return generateDeployScript; });
__webpack_require__.d(sc_namespaceObject, "ScriptBuilder", function() { return ScriptBuilder_ScriptBuilder; });
__webpack_require__.d(sc_namespaceObject, "StackItemType", function() { return StackItemType; });
__webpack_require__.d(sc_namespaceObject, "hasChildren", function() { return hasChildren; });
__webpack_require__.d(sc_namespaceObject, "StackItem", function() { return StackItem_StackItem; });
__webpack_require__.d(sc_namespaceObject, "OpCode", function() { return OpCode; });
// NAMESPACE OBJECT: ../neon-core/lib/wallet/index.js
var wallet_namespaceObject = {};
__webpack_require__.r(wallet_namespaceObject);
__webpack_require__.d(wallet_namespaceObject, "Account", function() { return Account_Account; });
__webpack_require__.d(wallet_namespaceObject, "Balance", function() { return Balance_Balance; });
__webpack_require__.d(wallet_namespaceObject, "Claims", function() { return Claims_Claims; });
__webpack_require__.d(wallet_namespaceObject, "getPublicKeyEncoded", function() { return getPublicKeyEncoded; });
__webpack_require__.d(wallet_namespaceObject, "getPublicKeyUnencoded", function() { return getPublicKeyUnencoded; });
__webpack_require__.d(wallet_namespaceObject, "getPrivateKeyFromWIF", function() { return getPrivateKeyFromWIF; });
__webpack_require__.d(wallet_namespaceObject, "getWIFFromPrivateKey", function() { return getWIFFromPrivateKey; });
__webpack_require__.d(wallet_namespaceObject, "getPublicKeyFromPrivateKey", function() { return getPublicKeyFromPrivateKey; });
__webpack_require__.d(wallet_namespaceObject, "getVerificationScriptFromPublicKey", function() { return getVerificationScriptFromPublicKey; });
__webpack_require__.d(wallet_namespaceObject, "getScriptHashFromPublicKey", function() { return getScriptHashFromPublicKey; });
__webpack_require__.d(wallet_namespaceObject, "getAddressFromScriptHash", function() { return getAddressFromScriptHash; });
__webpack_require__.d(wallet_namespaceObject, "getScriptHashFromAddress", function() { return getScriptHashFromAddress; });
__webpack_require__.d(wallet_namespaceObject, "generateSignature", function() { return generateSignature; });
__webpack_require__.d(wallet_namespaceObject, "generatePrivateKey", function() { return generatePrivateKey; });
__webpack_require__.d(wallet_namespaceObject, "encrypt", function() { return encrypt; });
__webpack_require__.d(wallet_namespaceObject, "decrypt", function() { return decrypt; });
__webpack_require__.d(wallet_namespaceObject, "isNEP2", function() { return isNEP2; });
__webpack_require__.d(wallet_namespaceObject, "isWIF", function() { return isWIF; });
__webpack_require__.d(wallet_namespaceObject, "isPrivateKey", function() { return isPrivateKey; });
__webpack_require__.d(wallet_namespaceObject, "isPublicKey", function() { return isPublicKey; });
__webpack_require__.d(wallet_namespaceObject, "isScriptHash", function() { return isScriptHash; });
__webpack_require__.d(wallet_namespaceObject, "isAddress", function() { return isAddress; });
__webpack_require__.d(wallet_namespaceObject, "curve", function() { return curve; });
__webpack_require__.d(wallet_namespaceObject, "sign", function() { return sign; });
__webpack_require__.d(wallet_namespaceObject, "verify", function() { return verify; });
__webpack_require__.d(wallet_namespaceObject, "AssetBalance", function() { return AssetBalance_AssetBalance; });
__webpack_require__.d(wallet_namespaceObject, "ClaimItem", function() { return ClaimItem_ClaimItem; });
__webpack_require__.d(wallet_namespaceObject, "Coin", function() { return Coin_Coin; });
__webpack_require__.d(wallet_namespaceObject, "Wallet", function() { return Wallet_Wallet; });
__webpack_require__.d(wallet_namespaceObject, "constructMultiSigVerificationScript", function() { return constructMultiSigVerificationScript; });
__webpack_require__.d(wallet_namespaceObject, "getPublicKeysFromVerificationScript", function() { return getPublicKeysFromVerificationScript; });
__webpack_require__.d(wallet_namespaceObject, "getSigningThresholdFromVerificationScript", function() { return getSigningThresholdFromVerificationScript; });
__webpack_require__.d(wallet_namespaceObject, "getSignaturesFromInvocationScript", function() { return getSignaturesFromInvocationScript; });
// NAMESPACE OBJECT: ../neon-core/lib/tx/index.js
var tx_namespaceObject = {};
__webpack_require__.r(tx_namespaceObject);
__webpack_require__.d(tx_namespaceObject, "TransactionAttribute", function() { return TransactionAttribute_TransactionAttribute; });
__webpack_require__.d(tx_namespaceObject, "TransactionInput", function() { return TransactionInput_TransactionInput; });
__webpack_require__.d(tx_namespaceObject, "TransactionOutput", function() { return TransactionOutput_TransactionOutput; });
__webpack_require__.d(tx_namespaceObject, "Witness", function() { return Witness_Witness; });
__webpack_require__.d(tx_namespaceObject, "StateType", function() { return StateType; });
__webpack_require__.d(tx_namespaceObject, "StateDescriptor", function() { return StateDescriptor_StateDescriptor; });
__webpack_require__.d(tx_namespaceObject, "BaseTransaction", function() { return BaseTransaction_BaseTransaction; });
__webpack_require__.d(tx_namespaceObject, "Transaction", function() { return Transaction_Transaction; });
__webpack_require__.d(tx_namespaceObject, "ClaimTransaction", function() { return ClaimTransaction_ClaimTransaction; });
__webpack_require__.d(tx_namespaceObject, "ContractTransaction", function() { return ContractTransaction_ContractTransaction; });
__webpack_require__.d(tx_namespaceObject, "InvocationTransaction", function() { return InvocationTransaction_InvocationTransaction; });
__webpack_require__.d(tx_namespaceObject, "StateTransaction", function() { return StateTransaction_StateTransaction; });
__webpack_require__.d(tx_namespaceObject, "MinerTransaction", function() { return MinerTransaction_MinerTransaction; });
__webpack_require__.d(tx_namespaceObject, "IssueTransaction", function() { return IssueTransaction_IssueTransaction; });
__webpack_require__.d(tx_namespaceObject, "RegisterTransaction", function() { return RegisterTransaction_RegisterTransaction; });
__webpack_require__.d(tx_namespaceObject, "TransactionType", function() { return TransactionType; });
__webpack_require__.d(tx_namespaceObject, "EnrollmentTransaction", function() { return EnrollmentTransaction_EnrollmentTransaction; });
__webpack_require__.d(tx_namespaceObject, "PublishTransaction", function() { return PublishTransaction_PublishTransaction; });
__webpack_require__.d(tx_namespaceObject, "smallestFirst", function() { return smallestFirst; });
__webpack_require__.d(tx_namespaceObject, "biggestFirst", function() { return biggestFirst; });
__webpack_require__.d(tx_namespaceObject, "balancedApproach", function() { return balancedApproach; });
__webpack_require__.d(tx_namespaceObject, "TxAttrUsage", function() { return TxAttrUsage; });
__webpack_require__.d(tx_namespaceObject, "defaultCalculationStrategy", function() { return defaultCalculationStrategy; });
// NAMESPACE OBJECT: ../neon-core/lib/settings.js
var settings_namespaceObject = {};
__webpack_require__.r(settings_namespaceObject);
__webpack_require__.d(settings_namespaceObject, "networks", function() { return networks; });
__webpack_require__.d(settings_namespaceObject, "defaultCalculationStrategy", function() { return defaultCalculationStrategy; });
__webpack_require__.d(settings_namespaceObject, "timeout", function() { return timeout; });
// NAMESPACE OBJECT: ../neon-core/lib/rpc/index.js
var rpc_namespaceObject = {};
__webpack_require__.r(rpc_namespaceObject);
__webpack_require__.d(rpc_namespaceObject, "Network", function() { return Network_Network; });
__webpack_require__.d(rpc_namespaceObject, "Protocol", function() { return Protocol_Protocol; });
__webpack_require__.d(rpc_namespaceObject, "queryRPC", function() { return queryRPC; });
__webpack_require__.d(rpc_namespaceObject, "Query", function() { return Query_Query; });
__webpack_require__.d(rpc_namespaceObject, "RPCClient", function() { return RPCClient_RPCClient; });
__webpack_require__.d(rpc_namespaceObject, "buildParser", function() { return buildParser; });
__webpack_require__.d(rpc_namespaceObject, "NoOpParser", function() { return NoOpParser; });
__webpack_require__.d(rpc_namespaceObject, "IntegerParser", function() { return IntegerParser; });
__webpack_require__.d(rpc_namespaceObject, "StringParser", function() { return StringParser; });
__webpack_require__.d(rpc_namespaceObject, "Fixed8Parser", function() { return Fixed8Parser; });
__webpack_require__.d(rpc_namespaceObject, "SimpleParser", function() { return SimpleParser; });
// CONCATENATED MODULE: ../neon-core/lib/consts.js
const ADDR_VERSION = "17";
const ASSETS = {
NEO: "NEO",
c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b: "NEO",
GAS: "GAS",
"602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7": "GAS",
};
const ASSET_ID = {
NEO: "c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
GAS: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
};
const ASSET_TYPE = {
CreditFlag: 0x40,
DutyFlag: 0x80,
GoverningToken: 0x00,
UtilityToken: 0x01,
Currency: 0x08,
Share: 0x90,
Invoice: 0x98,
Token: 0x60,
};
const CONTRACTS = {
RPX: "ecc6b20d3ccac1ee9ef109af5a7cdb85706b1df9",
TEST_RPX: "5b7074e873973a6ed3708862f219a6fbf4d1c411",
TEST_LWTF: "d7678dd97c000be3f33e9362e673101bac4ca654",
TEST_NXT: "0b6c1f919e95fe61c17a7612aebfaf4fda3a2214",
TEST_RHTT4: "f9572c5b119a6b5775a6af07f1cef5d310038f55",
};
const DEFAULT_RPC = {
MAIN: "https://seed11.ngd.network:10331",
TEST: "https://seed11.ngd.network:20331",
};
const DEFAULT_REQ = {
jsonrpc: "2.0",
method: "getblockcount",
params: [],
id: 1234,
};
const DEFAULT_SCRYPT = {
n: 16384,
r: 8,
p: 8,
size: 64,
};
const DEFAULT_SYSFEE = {
enrollmentTransaction: 1000,
issueTransaction: 500,
publishTransaction: 500,
registerTransaction: 10000,
};
const DEFAULT_WALLET = {
name: "myWallet",
version: "1.0",
scrypt: DEFAULT_SCRYPT,
extra: null,
};
const DEFAULT_ACCOUNT_CONTRACT = {
script: "",
parameters: [
{
name: "signature",
type: "Signature",
},
],
deployed: false,
};
const NEO_NETWORK = {
MAIN: "MainNet",
TEST: "TestNet",
};
// specified by nep2, same as bip38
const NEP_HEADER = "0142";
const NEP_FLAG = "e0";
const RPC_VERSION = "2.3.2";
const TX_VERSION = {
CLAIM: 0,
CONTRACT: 0,
INVOCATION: 1,
ISSUE: 0,
STATE: 0,
MINER: 0,
ENROLLMENT: 0,
PUBLISH: 0,
REGISTER: 0,
};
//# sourceMappingURL=consts.js.map
// EXTERNAL MODULE: /home/circleci/repo/node_modules/loglevel/lib/loglevel.js
var loglevel = __webpack_require__(11);
var loglevel_default = /*#__PURE__*/__webpack_require__.n(loglevel);
// EXTERNAL MODULE: /home/circleci/repo/node_modules/loglevel-plugin-prefix/lib/loglevel-plugin-prefix.js
var loglevel_plugin_prefix = __webpack_require__(32);
var loglevel_plugin_prefix_default = /*#__PURE__*/__webpack_require__.n(loglevel_plugin_prefix);
// CONCATENATED MODULE: ../neon-core/lib/logging.js
loglevel_plugin_prefix_default.a.reg(loglevel_default.a);
loglevel_default.a.setDefaultLevel("silent");
function setAll(lvl) {
Object.keys(loglevel_default.a.getLoggers()).map((key) => {
const lg = loglevel_default.a.getLogger(key);
lg.setLevel(lvl);
});
}
const fn = (level, name, timestamp) => {
const ts = timestamp ? timestamp : new Date().toUTCString();
level = level.toUpperCase();
return `[${ts}] (${name}) ${level}: `;
};
/* harmony default export */ var logging = ((label) => {
const l = loglevel_default.a.getLogger(label);
loglevel_plugin_prefix_default.a.apply(l, { format: fn });
return l;
});
const logger = loglevel_default.a;
//# sourceMappingURL=logging.js.map
// CONCATENATED MODULE: ../neon-core/lib/helper.js
function compareNeonObjectArray(arr1, arr2 = []) {
if (arr1.length !== arr2.length) {
return false;
}
for (const c of arr1) {
if (!arr2.find((cl) => c.equals(c))) {
return false;
}
}
return true;
}
function compareObject(current, other) {
const keys = Object.keys(current);
const otherKeys = Object.keys(other);
if (keys.length !== otherKeys.length) {
return false;
}
for (const key of keys) {
if (other[key] !== undefined && current[key] === other[key]) {
continue;
}
return false;
}
return true;
}
function compareUnsortedPlainArrays(current, other) {
if (!Array.isArray(current) ||
!Array.isArray(other) ||
current.length !== other.length) {
return false;
}
for (let i = 0; i < current.length; i++) {
if (current[i] !== other[i]) {
return false;
}
}
return true;
}
function compareArray(current, other) {
if (current.length !== other.length) {
return false;
}
for (let i = 0; i < current.length; i++) {
if (typeof current[i] === "object" && typeof other[i] === "object") {
const objectEquality = compareObject(current[i], other[i]);
if (!objectEquality) {
return false;
}
}
if (current[i] !== other[i]) {
return false;
}
}
return true;
}
//# sourceMappingURL=helper.js.map
// CONCATENATED MODULE: ../neon-core/lib/rpc/Protocol.js
const log = logging("protocol");
function compareArrays(current, other) {
if (current.length !== other.length) {
return false;
}
for (let i = 0; i < current.length; i++) {
if (current[i] !== other[i]) {
return false;
}
}
return true;
}
/**
* Model of the protocol configuration file used by the C# implementation.
*/
class Protocol_Protocol {
constructor(config = {}) {
this.magic = config.magic || config.Magic || 0;
this.addressVersion = config.addressVersion || config.AddressVersion || 23;
this.standbyValidators =
config.standbyValidators || config.StandbyValidators || [];
this.seedList = config.seedList || config.SeedList || [];
this.systemFee = Object.assign({}, config.systemFee || config.SystemFee || DEFAULT_SYSFEE);
}
get [Symbol.toStringTag]() {
return "Protocol";
}
export() {
return {
Magic: this.magic,
AddressVersion: this.addressVersion,
StandbyValidators: this.standbyValidators,
SeedList: this.seedList,
SystemFee: this.systemFee,
};
}
equals(other) {
return (this.magic === (other.magic || other.Magic) &&
this.addressVersion === (other.addressVersion || other.AddressVersion) &&
compareArrays(this.seedList, other.seedList || other.SeedList || []) &&
compareArrays(this.standbyValidators, other.standbyValidators || other.StandbyValidators || []) &&
compareObject(this.systemFee, other.systemFee || other.SystemFee || {}));
}
}
/* harmony default export */ var rpc_Protocol = (Protocol_Protocol);
//# sourceMappingURL=Protocol.js.map
// CONCATENATED MODULE: ../neon-core/lib/rpc/Network.js
const Network_log = logging("protocol");
/**
* Network interface representing a NEO blockchain network.
* This inherits from the network.protocol file used in the C# implementation and adds in additional configurations.
* @param config NetworkLike JS object
*/
class Network_Network {
constructor(config = {}, name = null) {
this.name = config.Name || config.name || name || "RandomNet";
const protocolLike = Object.assign({}, config.protocol || config.ProtocolConfiguration || {});
this.protocol = new rpc_Protocol(protocolLike);
this.nodes = config.Nodes || config.nodes || [];
this.extra = Object.assign({}, config.ExtraConfiguration || config.extra || {});
}
/**
* Exports the class as a JSON format.
*/
export() {
return {
ProtocolConfiguration: this.protocol.export(),
Name: this.name,
ExtraConfiguration: this.extra,
Nodes: this.nodes,
};
}
equals(other) {
return (this.name === other.name &&
this.protocol.equals(other.protocol || {}) &&
compareUnsortedPlainArrays(this.nodes, other.nodes || []) &&
compareObject(this.extra, other.extra || {}));
}
}
/* harmony default export */ var rpc_Network = (Network_Network);
//# sourceMappingURL=Network.js.map
// EXTERNAL MODULE: /home/circleci/repo/node_modules/axios/index.js
var axios = __webpack_require__(1);
var axios_default = /*#__PURE__*/__webpack_require__.n(axios);
// CONCATENATED MODULE: /home/circleci/repo/node_modules/bignumber.js/bignumber.mjs
/*
* bignumber.js v7.2.1
* A JavaScript library for arbitrary-precision arithmetic.
* https://github.com/MikeMcl/bignumber.js
* Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
* MIT Licensed.
*
* BigNumber.prototype methods | BigNumber methods
* |
* absoluteValue abs | clone
* comparedTo | config set
* decimalPlaces dp | DECIMAL_PLACES
* dividedBy div | ROUNDING_MODE
* dividedToIntegerBy idiv | EXPONENTIAL_AT
* exponentiatedBy pow | RANGE
* integerValue | CRYPTO
* isEqualTo eq | MODULO_MODE
* isFinite | POW_PRECISION
* isGreaterThan gt | FORMAT
* isGreaterThanOrEqualTo gte | ALPHABET
* isInteger | isBigNumber
* isLessThan lt | maximum max
* isLessThanOrEqualTo lte | minimum min
* isNaN | random
* isNegative |
* isPositive |
* isZero |
* minus |
* modulo mod |
* multipliedBy times |
* negated |
* plus |
* precision sd |
* shiftedBy |
* squareRoot sqrt |
* toExponential |
* toFixed |
* toFormat |
* toFraction |
* toJSON |
* toNumber |
* toPrecision |
* toString |
* valueOf |
*
*/
var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i,
mathceil = Math.ceil,
mathfloor = Math.floor,
bignumberError = '[BigNumber Error] ',
tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',
BASE = 1e14,
LOG_BASE = 14,
MAX_SAFE_INTEGER = 0x1fffffffffffff, // 2^53 - 1
// MAX_INT32 = 0x7fffffff, // 2^31 - 1
POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],
SQRT_BASE = 1e7,
// EDITABLE
// The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and
// the arguments to toExponential, toFixed, toFormat, and toPrecision.
MAX = 1E9; // 0 to MAX_INT32
/*
* Create and return a BigNumber constructor.
*/
function clone(configObject) {
var div, convertBase, parseNumeric,
P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },
ONE = new BigNumber(1),
//----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------
// The default values below must be integers within the inclusive ranges stated.
// The values can also be changed at run-time using BigNumber.set.
// The maximum number of decimal places for operations involving division.
DECIMAL_PLACES = 20, // 0 to MAX
// The rounding mode used when rounding to the above decimal places, and when using
// toExponential, toFixed, toFormat and toPrecision, and round (default value).
// UP 0 Away from zero.
// DOWN 1 Towards zero.
// CEIL 2 Towards +Infinity.
// FLOOR 3 Towards -Infinity.
// HALF_UP 4 Towards nearest neighbour. If equidistant, up.
// HALF_DOWN 5 Towards nearest neighbour. If equidistant, down.
// HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour.
// HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity.
// HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
ROUNDING_MODE = 4, // 0 to 8
// EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]
// The exponent value at and beneath which toString returns exponential notation.
// Number type: -7
TO_EXP_NEG = -7, // 0 to -MAX
// The exponent value at and above which toString returns exponential notation.
// Number type: 21
TO_EXP_POS = 21, // 0 to MAX
// RANGE : [MIN_EXP, MAX_EXP]
// The minimum exponent value, beneath which underflow to zero occurs.
// Number type: -324 (5e-324)
MIN_EXP = -1e7, // -1 to -MAX
// The maximum exponent value, above which overflow to Infinity occurs.
// Number type: 308 (1.7976931348623157e+308)
// For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.
MAX_EXP = 1e7, // 1 to MAX
// Whether to use cryptographically-secure random number generation, if available.
CRYPTO = false, // true or false
// The modulo mode used when calculating the modulus: a mod n.
// The quotient (q = a / n) is calculated according to the corresponding rounding mode.
// The remainder (r) is calculated as: r = a - n * q.
//
// UP 0 The remainder is positive if the dividend is negative, else is negative.
// DOWN 1 The remainder has the same sign as the dividend.
// This modulo mode is commonly known as 'truncated division' and is
// equivalent to (a % n) in JavaScript.
// FLOOR 3 The remainder has the same sign as the divisor (Python %).
// HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.
// EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)).
// The remainder is always positive.
//
// The truncated division, floored division, Euclidian division and IEEE 754 remainder
// modes are commonly used for the modulus operation.
// Although the other rounding modes can also be used, they may not give useful results.
MODULO_MODE = 1, // 0 to 9
// The maximum number of significant digits of the result of the exponentiatedBy operation.
// If POW_PRECISION is 0, there will be unlimited significant digits.
POW_PRECISION = 0, // 0 to MAX
// The format specification used by the BigNumber.prototype.toFormat method.
FORMAT = {
decimalSeparator: '.',
groupSeparator: ',',
groupSize: 3,
secondaryGroupSize: 0,
fractionGroupSeparator: '\xA0', // non-breaking space
fractionGroupSize: 0
},
// The alphabet used for base conversion.
// It must be at least 2 characters long, with no '.' or repeated character.
// '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
//------------------------------------------------------------------------------------------
// CONSTRUCTOR
/*
* The BigNumber constructor and exported function.
* Create and return a new instance of a BigNumber object.
*
* n {number|string|BigNumber} A numeric value.
* [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.
*/
function BigNumber(n, b) {
var alphabet, c, caseChanged, e, i, isNum, len, str,
x = this;
// Enable constructor usage without new.
if (!(x instanceof BigNumber)) {
// Don't throw on constructor call without new (#81).
// '[BigNumber Error] Constructor call without new: {n}'
//throw Error(bignumberError + ' Constructor call without new: ' + n);
return new BigNumber(n, b);
}
if (b == null) {
// Duplicate.
if (n instanceof BigNumber) {
x.s = n.s;
x.e = n.e;
x.c = (n = n.c) ? n.slice() : n;
return;
}
isNum = typeof n == 'number';
if (isNum && n * 0 == 0) {
// Use `1 / n` to handle minus zero also.
x.s = 1 / n < 0 ? (n = -n, -1) : 1;
// Faster path for integers.
if (n === ~~n) {
for (e = 0, i = n; i >= 10; i /= 10, e++);
x.e = e;
x.c = [n];
return;
}
str = n + '';
} else {
if (!isNumeric.test(str = n + '')) return parseNumeric(x, str, isNum);
x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
}
// Decimal point?
if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
// Exponential form?
if ((i = str.search(/e/i)) > 0) {
// Determine exponent.
if (e < 0) e = i;
e += +str.slice(i + 1);
str = str.substring(0, i);
} else if (e < 0) {
// Integer.
e = str.length;
}
} else {
// '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'
intCheck(b, 2, ALPHABET.length, 'Base');
str = n + '';
// Allow exponential notation to be used with base 10 argument, while
// also rounding to DECIMAL_PLACES as with other bases.
if (b == 10) {
x = new BigNumber(n instanceof BigNumber ? n : str);
return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
}
isNum = typeof n == 'number';
if (isNum) {
// Avoid potential interpretation of Infinity and NaN as base 44+ values.
if (n * 0 != 0) return parseNumeric(x, str, isNum, b);
x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;
// '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
if (BigNumber.DEBUG && str.replace(/^0\.0*|\./, '').length > 15) {
throw Error
(tooManyDigits + n);
}
// Prevent later check for length on converted number.
isNum = false;
} else {
x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
}
alphabet = ALPHABET.slice(0, b);
e = i = 0;
// Check that str is a valid base b number.
// Don't use RegExp so alphabet can contain special characters.
for (len = str.length; i < len; i++) {
if (alphabet.indexOf(c = str.charAt(i)) < 0) {
if (c == '.') {
// If '.' is not the first character and it has not be found before.
if (i > e) {
e = len;
continue;
}
} else if (!caseChanged) {
// Allow e.g. hexadecimal 'FF' as well as 'ff'.
if (str == str.toUpperCase() && (str = str.toLowerCase()) ||
str == str.toLowerCase() && (str = str.toUpperCase())) {
caseChanged = true;
i = -1;
e = 0;
continue;
}
}
return parseNumeric(x, n + '', isNum, b);
}
}
str = convertBase(str, b, 10, x.s);
// Decimal point?
if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
else e = str.length;
}
// Determine leading zeros.
for (i = 0; str.charCodeAt(i) === 48; i++);
// Determine trailing zeros.
for (len = str.length; str.charCodeAt(--len) === 48;);
str = str.slice(i, ++len);
if (str) {
len -= i;
// '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
if (isNum && BigNumber.DEBUG &&
len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {
throw Error
(tooManyDigits + (x.s * n));
}
e = e - i - 1;
// Overflow?
if (e > MAX_EXP) {
// Infinity.
x.c = x.e = null;
// Underflow?
} else if (e < MIN_EXP) {
// Zero.
x.c = [x.e = 0];
} else {
x.e = e;
x.c = [];
// Transform base
// e is the base 10 exponent.
// i is where to slice str to get the first element of the coefficient array.
i = (e + 1) % LOG_BASE;
if (e < 0) i += LOG_BASE;
if (i < len) {
if (i) x.c.push(+str.slice(0, i));
for (len -= LOG_BASE; i < len;) {
x.c.push(+str.slice(i, i += LOG_BASE));
}
str = str.slice(i);
i = LOG_BASE - str.length;
} else {
i -= len;
}
for (; i--; str += '0');
x.c.push(+str);
}
} else {
// Zero.
x.c = [x.e = 0];
}
}
// CONSTRUCTOR PROPERTIES
BigNumber.clone = clone;
BigNumber.ROUND_UP = 0;
BigNumber.ROUND_DOWN = 1;
BigNumber.ROUND_CEIL = 2;
BigNumber.ROUND_FLOOR = 3;
BigNumber.ROUND_HALF_UP = 4;
BigNumber.ROUND_HALF_DOWN = 5;
BigNumber.ROUND_HALF_EVEN = 6;
BigNumber.ROUND_HALF_CEIL = 7;
BigNumber.ROUND_HALF_FLOOR = 8;
BigNumber.EUCLID = 9;
/*
* Configure infrequently-changing library-wide settings.
*
* Accept an object with the following optional properties (if the value of a property is
* a number, it must be an integer within the inclusive range stated):
*
* DECIMAL_PLACES {number} 0 to MAX
* ROUNDING_MODE {number} 0 to 8
* EXPONENTIAL_AT {number|number[]} -MAX to MAX or [-MAX to 0, 0 to MAX]
* RANGE {number|number[]} -MAX to MAX (not zero) or [-MAX to -1, 1 to MAX]
* CRYPTO {boolean} true or false
* MODULO_MODE {number} 0 to 9
* POW_PRECISION {number} 0 to MAX
* ALPHABET {string} A string of two or more unique characters which does
* not contain '.'.
* FORMAT {object} An object with some of the following properties:
* decimalSeparator {string}
* groupSeparator {string}
* groupSize {number}
* secondaryGroupSize {number}
* fractionGroupSeparator {string}
* fractionGroupSize {number}
*
* (The values assigned to the above FORMAT object properties are not checked for validity.)
*
* E.g.
* BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })
*
* Ignore properties/parameters set to null or undefined, except for ALPHABET.
*
* Return an object with the properties current values.
*/
BigNumber.config = BigNumber.set = function (obj) {
var p, v;
if (obj != null) {
if (typeof obj == 'object') {
// DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.
// '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'
if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {
v = obj[p];
intCheck(v, 0, MAX, p);
DECIMAL_PLACES = v;
}
// ROUNDING_MODE {number} Integer, 0 to 8 inclusive.
// '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'
if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {
v = obj[p];
intCheck(v, 0, 8, p);
ROUNDING_MODE = v;
}
// EXPONENTIAL_AT {number|number[]}
// Integer, -MAX to MAX inclusive or
// [integer -MAX to 0 inclusive, 0 to MAX inclusive].
// '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'
if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {
v = obj[p];
if (isArray(v)) {
intCheck(v[0], -MAX, 0, p);
intCheck(v[1], 0, MAX, p);
TO_EXP_NEG = v[0];
TO_EXP_POS = v[1];
} else {
intCheck(v, -MAX, MAX, p);
TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
}
}
// RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or
// [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].
// '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'
if (obj.hasOwnProperty(p = 'RANGE')) {
v = obj[p];
if (isArray(v)) {
intCheck(v[0], -MAX, -1, p);
intCheck(v[1], 1, MAX, p);
MIN_EXP = v[0];
MAX_EXP = v[1];
} else {
intCheck(v, -MAX, MAX, p);
if (v) {
MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
} else {
throw Error
(bignumberError + p + ' cannot be zero: ' + v);
}
}
}
// CRYPTO {boolean} true or false.
// '[BigNumber Error] CRYPTO not true or false: {v}'
// '[BigNumber Error] crypto unavailable'
if (obj.hasOwnProperty(p = 'CRYPTO')) {
v = obj[p];
if (v === !!v) {
if (v) {
if (typeof crypto != 'undefined' && crypto &&
(crypto.getRandomValues || crypto.randomBytes)) {
CRYPTO = v;
} else {
CRYPTO = !v;
throw Error
(bignumberError + 'crypto unavailable');
}
} else {
CRYPTO = v;
}
} else {
throw Error
(bignumberError + p + ' not true or false: ' + v);
}
}
// MODULO_MODE {number} Integer, 0 to 9 inclusive.
// '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'
if (obj.hasOwnProperty(p = 'MODULO_MODE')) {
v = obj[p];
intCheck(v, 0, 9, p);
MODULO_MODE = v;
}
// POW_PRECISION {number} Integer, 0 to MAX inclusive.
// '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'
if (obj.hasOwnProperty(p = 'POW_PRECISION')) {
v = obj[p];
intCheck(v, 0, MAX, p);
POW_PRECISION = v;
}
// FORMAT {object}
// '[BigNumber Error] FORMAT not an object: {v}'
if (obj.hasOwnProperty(p = 'FORMAT')) {
v = obj[p];
if (typeof v == 'object') FORMAT = v;
else throw Error
(bignumberError + p + ' not an object: ' + v);
}
// ALPHABET {string}
// '[BigNumber Error] ALPHABET invalid: {v}'
if (obj.hasOwnProperty(p = 'ALPHABET')) {
v = obj[p];
// Disallow if only one character, or contains '.' or a repeated character.
if (typeof v == 'string' && !/^.$|\.|(.).*\1/.test(v)) {
ALPHABET = v;
} else {
throw Error
(bignumberError + p + ' invalid: ' + v);
}
}
} else {
// '[BigNumber Error] Object expected: {v}'
throw Error
(bignumberError + 'Object expected: ' + obj);
}
}
return {
DECIMAL_PLACES: DECIMAL_PLACES,
ROUNDING_MODE: ROUNDING_MODE,
EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
RANGE: [MIN_EXP, MAX_EXP],
CRYPTO: CRYPTO,
MODULO_MODE: MODULO_MODE,
POW_PRECISION: POW_PRECISION,
FORMAT: FORMAT,
ALPHABET: ALPHABET
};
};
/*
* Return true if v is a BigNumber instance, otherwise return false.
*
* v {any}
*/
BigNumber.isBigNumber = function (v) {
return v instanceof BigNumber || v && v._isBigNumber === true || false;
};
/*
* Return a new BigNumber whose value is the maximum of the arguments.
*
* arguments {number|string|BigNumber}
*/
BigNumber.maximum = BigNumber.max = function () {
return maxOrMin(arguments, P.lt);
};
/*
* Return a new BigNumber whose value is the minimum of the arguments.
*
* arguments {number|string|BigNumber}
*/
BigNumber.minimum = BigNumber.min = function () {
return maxOrMin(arguments, P.gt);
};
/*
* Return a new BigNumber with a random value equal to or greater than 0 and less than 1,
* and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing
* zeros are produced).
*
* [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
*
* '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'
* '[BigNumber Error] crypto unavailable'
*/
BigNumber.random = (function () {
var pow2_53 = 0x20000000000000;
// Return a 53 bit integer n, where 0 <= n < 9007199254740992.
// Check if Math.random() produces more than 32 bits of randomness.
// If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.
// 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.
var random53bitInt = (Math.random() * pow2_53) & 0x1fffff
? function () { return mathfloor(Math.random() * pow2_53); }
: function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +
(Math.random() * 0x800000 | 0); };
return function (dp) {
var a, b, e, k, v,
i = 0,
c = [],
rand = new BigNumber(ONE);
if (dp == null) dp = DECIMAL_PLACES;
else intCheck(dp, 0, MAX);
k = mathceil(dp / LOG_BASE);
if (CRYPTO) {
// Browsers supporting crypto.getRandomValues.
if (crypto.getRandomValues) {
a = crypto.getRandomValues(new Uint32Array(k *= 2));
for (; i < k;) {
// 53 bits:
// ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)
// 11111 11111111 11111111 11111111 11100000 00000000 00000000
// ((Math.pow(2, 32) - 1) >>> 11).toString(2)
// 11111 11111111 11111111
// 0x20000 is 2^21.
v = a[i] * 0x20000 + (a[i + 1] >>> 11);
// Rejection sampling:
// 0 <= v < 9007199254740992
// Probability that v >= 9e15, is
// 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251
if (v >= 9e15) {
b = crypto.getRandomValues(new Uint32Array(2));
a[i] = b[0];
a[i + 1] = b[1];
} else {
// 0 <= v <= 8999999999999999
// 0 <= (v % 1e14) <= 99999999999999
c.push(v % 1e14);
i += 2;
}
}
i = k / 2;
// Node.js supporting crypto.randomBytes.
} else if (crypto.randomBytes) {
// buffer
a = crypto.randomBytes(k *= 7);
for (; i < k;) {
// 0x1000000000000 is 2^48, 0x1000000000