@timestope-official/bitcoinkrypton-browser 0.0.1-0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (20) hide show
  1. package/README.md +72 -0
  2. package/VERSION +5 -0
  3. package/krypton.js +2 -0
  4. package/krypton.js.map +1 -0
  5. package/namespace.d.ts +8 -0
  6. package/package.json +41 -0
  7. package/types.d.ts +4353 -0
  8. package/web-babel.js +2 -0
  9. package/web-babel.js.map +1 -0
  10. package/web-offline.js +2 -0
  11. package/web-offline.js.map +1 -0
  12. package/web.esm.js +2 -0
  13. package/web.esm.js.map +1 -0
  14. package/web.js +2 -0
  15. package/web.js.map +1 -0
  16. package/worker-js.js +1 -0
  17. package/worker-wasm.js +1 -0
  18. package/worker-wasm.wasm +0 -0
  19. package/worker.js +2 -0
  20. package/worker.js.map +1 -0
package/web-offline.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["src/main/platform/browser/index.prefix.js","src/main/platform/browser/Class.js","src/main/platform/browser/utils/LogNative.js","src/main/generic/utils/Log.js","src/main/generic/utils/Observable.js","src/main/platform/browser/crypto/CryptoLib.js","src/main/platform/browser/utils/PlatformUtils.js","src/main/platform/browser/WasmHelper.js","src/main/generic/utils/array/ArrayUtils.js","src/main/generic/utils/assert/Assert.js","src/main/generic/utils/buffer/BufferUtils.js","src/main/generic/utils/buffer/SerialBuffer.js","src/main/generic/utils/crc/CRC8.js","src/main/generic/utils/number/BigNumber.js","src/main/generic/utils/number/NumberUtils.js","src/main/generic/utils/merkle/MerkleTree.js","src/main/generic/utils/merkle/MerklePath.js","src/main/generic/utils/mnemonic/MnemonicUtils.js","src/main/generic/utils/string/StringUtils.js","src/main/generic/consensus/Policy.js","src/main/generic/consensus/base/primitive/Serializable.js","src/main/generic/consensus/base/primitive/Hash.js","src/main/generic/consensus/base/primitive/Secret.js","src/main/generic/consensus/base/primitive/PrivateKey.js","src/main/generic/consensus/base/primitive/PublicKey.js","src/main/generic/consensus/base/primitive/KeyPair.js","src/main/generic/consensus/base/primitive/Entropy.js","src/main/generic/consensus/base/primitive/ExtendedPrivateKey.js","src/main/generic/consensus/base/primitive/RandomSecret.js","src/main/generic/consensus/base/primitive/Signature.js","src/main/generic/consensus/base/primitive/Commitment.js","src/main/generic/consensus/base/primitive/CommitmentPair.js","src/main/generic/consensus/base/primitive/PartialSignature.js","src/main/generic/consensus/base/account/Address.js","src/main/generic/consensus/base/account/Bech32.js","src/main/generic/consensus/base/account/Account.js","src/main/generic/consensus/base/account/BasicAccount.js","src/main/generic/consensus/base/account/Contract.js","src/main/generic/consensus/base/account/HashedTimeLockedContract.js","src/main/generic/consensus/base/account/VestingContract.js","src/main/generic/consensus/base/transaction/Transaction.js","src/main/generic/consensus/base/transaction/SignatureProof.js","src/main/generic/consensus/base/transaction/BasicTransaction.js","src/main/generic/consensus/base/transaction/ExtendedTransaction.js","src/main/generic/utils/IWorker.js","src/main/generic/utils/crypto/CryptoWorker.js","src/main/generic/utils/crypto/CryptoUtils.js","src/main/generic/consensus/GenesisConfigOffline.js","src/main/platform/browser/index.suffix.js"],"names":["Krypton","window","Proxy","exports","_currentScript","document","currentScript","scripts","getElementsByTagName","length","_path","src","indexOf","substring","lastIndexOf","Class","scope","self","[object Object]","cls","name","register","LogNative","this","_global_level","Log","INFO","_tag_levels","localStorage","c","getItem","JSON","parse","e","console","warn","tag","level","setItem","stringify","args","isLoggable","unshift","Level","toStringTag","Date","toTimeString","substr","error","ERROR","apply","WARNING","info","debug","DEBUG","trace","TRACE","log","instance","_instance","native","_native","setLoggable","get","l","i","toString","constructor","msg","message","arguments","Array","prototype","slice","call","undefined","VERBOSE","ASSERT","v","isNaN","parseInt","toLowerCase","d","bind","w","t","Observable","WILDCARD","_listeners","Map","clear","type","callback","has","push","set","id","promises","listeners","key","hasOwnProperty","res","Promise","catch","all","observable","types","fire","on","CryptoLib","getRandomValues","crypto","msCrypto","PlatformUtils","RTCPeerConnection","isBrowser","webkitRTCPeerConnection","createDataChannel","location","protocol","navigator","onLine","test","platform","userAgentString","hardwareConcurrency","WasmHelper","doImportBrowser","_importBrowserPromise","importWasmBrowser","importScriptBrowser","wasm","module","_adjustWasmPath","_global","WebAssembly","resolve","xhr","XMLHttpRequest","open","responseType","onload","wasmBinary","response","onerror","send","script","integrity","asm","_adjustScriptPath","moduleSettings","async","reject","runtimeInitialized","onRuntimeInitialized","importScripts","_moduleLoadedCallbacks","_loadBrowserScript","require","url","head","createElement","crossOrigin","appendChild","__dirname","global","ArrayUtils","arr","Math","floor","random","uintarr","begin","end","clamp","min","max","byteLength","len","Uint8Array","buffer","byteOffset","list","k","n","indices","from","x","map","reverseRange","found","j","Assert","condition","Error","BufferUtils","buf","_toUint8View","ascii","String","fromCharCode","subarray","string","charCodeAt","TextDecoder","_ISO_8859_15_DECODER","uint8View","decode","replace","num","_BASE64_LOOKUP","u8","start","tmp","output","_tripletToBase64","join","extraBytes","parts","len2","_base64encodeChunk","isNodeJs","Buffer","btoa","_codePointTextDecoder","_base64fromByteArray","base64","atob","split","SerialBuffer","toBase64","fromBase64","alphabet","BASE32_ALPHABET","KRYPTON","byte","symbol","shift","carry","base32","charmap","toUpperCase","forEach","char","hex","code","HEX_ALPHABET","trim","StringUtils","isHexBytes","match","bin","lpad","str","out","p","TextEncoder","_UTF8_ENCODER","encode","_utf8TextEncoder","_strToUint8Array","o","EMPTY","fromHex","a","b","viewA","viewB","arrayLike","ArrayBuffer","BASE58_ALPHABET","strOutput","base58","bOutput","prefix","suffix","input","checksum","Hash","computeSha256","toBase58","hasSuffix","fromBase58","BASE64_ALPHABET","RFC4648","RFC4648_HEX","bufferOrArrayOrLength","super","_view","DataView","_readPos","_writePos","readPos","value","writePos","array","getUint8","setUint8","getUint16","setUint16","getUint32","setUint32","pow","NumberUtils","isUint64","op96","BigNumber","op64","op32","part1","part2","part3","part4","times","plus","isUint128","idiv","mod","toNumber","readUint8","readUint16","readUint32","readUint64","writeUint8","writeUint16","writeUint32","writeUint64","getFloat64","setFloat64","bytes","read","toAscii","isMultibyte","fromAscii","write","view","padding","isUint8","sources","reduce","acc","result","offset","CRC8","table","curr","_table","_createTable","globalObject","isNumeric","mathceil","ceil","mathfloor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","s","z","r","compare","y","xc","yc","intCheck","isArray","obj","Object","isOdd","toExponential","charAt","toFixedPoint","zs","clone","configObject","div","convertBase","parseNumeric","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","decimalSeparator","groupSeparator","groupSize","secondaryGroupSize","fractionGroupSeparator","fractionGroupSize","ALPHABET","isNum","round","search","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","_isBigNumber","maximum","maxOrMin","lt","minimum","gt","dp","rand","Uint32Array","copy","pop","splice","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","rm","concat","multiply","base","m","temp","xlo","xhi","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","format","c0","ne","method","normalise","p1","p2","sd","ni","rd","pows10","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","integerValue","isEqualTo","eq","equals","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toPrecision","toJSON","val","Number","UINT8_MAX","UINT16_MAX","UINT32_MAX","UINT64_MAX","UINT128_MAX","MerkleTree","values","fnHash","_hash","_computeRoot","light","mid","left","right","leftHash","rightHash","concatTypedArrays","serialize","hash","MerklePath","nodes","some","it","MerklePathNode","_nodes","leafValue","leafHash","path","_compute","containsLeaf","inner","leftLeaf","rightLeaf","root","node","serializedSize","count","leftBitsSize","leftBits","algorithm","unserialize","_compress","sum","every","_left","MnemonicUtils","entropy","CS","compute","toBinary","Entropy","bits","wordlist","chunk","index","fromBinary","mnemonic","words","word","legacy","dividerIndex","entropyBits","checksumBits","entropyBytes","_crcChecksum","_sha256Checksum","DEFAULT_WORDLIST","_normalizeEntropy","_entropyToBits","_bitsToMnemonic","_mnemonicToBits","_bitsToEntropy","password","mnemonicBuffer","saltBuffer","_salt","CryptoUtils","computePBKDF2sha512","seed","mnemonicToSeed","ExtendedPrivateKey","generateMasterKey","normalizedEntropy","isBIP39","isLegacy","MnemonicType","UNKNOWN","BIP39","LEGACY","ENGLISH_WORDLIST","freeze","isHex","str1","str2","padString","Policy","coins","SATOSHIS_PER_COIN","satoshis","blockHeight","halving","HALVING_INTERVAL","HALVING_TARGET_MAX","INITIAL_BLOCK_REWARD","BLOCK_TIME_MILESTONE","INITIAL_BLOCK_TIME","BLOCK_TIME_MULTIPLE","initial","secondBlockTime","target","height","beginBlock","endBlock","blockMilestoneMax","range","beginRangeIndex","beginBlocksTime","endRangeIndex","endBlocksTime","middleBlocksTime","changing","TX_FEE_CHANGING_INTERVAL","TX_FEE_CHANGING_TOTAL_NUMBER","INITIAL_TX_FEE","FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE","INITIAL_BLOCK_SIZE","BASE_BLOCK_SIZE","BLOCK_SIZE_FACTOR","BLOCK_SIZE_CHANGING_INTERVAL","SECOND_FORKING_FOR_BLOCK_DIFFICULTY","DIFFICULTY_BLOCK_WINDOW","time","blockTime","BLOCK_TARGET_MAX","DIFFICULTY_MAX_ADJUSTMENT_FACTOR","NEW_DIFFICULTY_MAX_ADJUSTMENT_FACTOR","NEW_DIFFICULTY_MIN_ADJUSTMENT_FACTOR","SECOND_DIFFICULTY_MAX_ADJUSTMENT_FACTOR","SECOND_DIFFICULTY_MIN_ADJUSTMENT_FACTOR","TRANSACTION_VALIDITY_WINDOW","INITIAL_SUPPLY","M","K","DELTA","NUM_BLOCKS_VERIFICATION","NUM_SNAPSHOTS_MAX","Serializable","toHex","toBase58Check","arg","Algorithm","BLAKE2B","getSize","_obj","_algorithm","blake2b","computeBlake2b","argon2d","CryptoWorker","getInstanceAsync","computeArgon2d","ARGON2D","SHA256","computeSha512","SHA512","computeRipemd160","RIPEMD160","ripemd160","computeKeccak256","KECCAK256","sha256","SIZE","fromAny","fromString","size","NodeNative","node_blake2","stackPtr","Module","stackSave","hashSize","wasmOut","stackAlloc","wasmIn","HEAPU8","_krypton_blake2","stackRestore","node_sha256","_krypton_sha256","node_sha512","_krypton_sha512","node_ripemd160","_ripemd160","node_keccak256","_keccak256","hashAlgorithm","NULL","Secret","purposeId","_type","_purposeId","version","roundsLog","rounds","_decryptV1","_decryptV2","_decryptV3","ciphertext","salt","ENCRYPTION_SALT_SIZE","check","ENCRYPTION_CHECKSUM_SIZE","plaintext","otpKdfLegacy","privateKey","PrivateKey","PublicKey","derive","ENCRYPTION_CHECKSUM_SIZE_V3","otpKdf","payload","secret","PURPOSE_ID","lib","data","ENCRYPTION_KDF_ROUNDS","log2","encryptedSize","Type","PRIVATE_KEY","ENTROPY","publicKey","publicKeysHash","node_secp256k1_derive_delinearized_seckey","wasmInPrivateKey","wasmInPublicKey","wasmInPublicKeysHash","_secp256k1_derive_delinearized_seckey","delinearizedPrivateKey","CryptoWorkerImpl","_publicKeyDerive","_compressPublicKey","publicKeys","sort","_delinearizeAndAggregatePublicKeys","keccak256","Address","fromHash","PeerId","publicKeysObj","_publicKeysHash","raw","_publicKeysDelinearizeAndAggregate","randomize","node_secp256k1_ctx_init","COMPRESSED_SIZE","node_secp256k1_pubkey_compress","node_secp256k1_ctx_release","rdm","HEAP8","_secp256k1_ctx_init","pubKeyBufferOut","_secp256k1_pubkey_compress","compressed","_secp256k1_ctx_release","node_secp256k1_pubkey_create","pubKeyBuffer","privKeyBuffer","_secp256k1_pubkey_create","fill","concatenatedPublicKeys","node_secp256k1_hash_pubkeys","wasmInPublicKeys","_secp256k1_hash_pubkeys","hashedPublicKey","node_secp256k1_delinearize_pubkey","_secp256k1_delinearize_pubkey","delinearizedPublicKey","node_secp256k1_aggregate_delinearized_publkeys","_secp256k1_aggregate_delinearized_publkeys","aggregatePublicKey","KeyPair","locked","lockSalt","_locked","_lockedInternally","_lockSalt","_publicKey","_internalPrivateKey","generate","hexBuf","_privateKey","isLocked","_unlockedPrivateKey","overwrite","_otpPrivateKey","_clearUnlockedPrivateKey","LOCK_KDF_ROUNDS","fromEncrypted","exportEncrypted","mnemonicToExtendedPrivateKey","toMnemonic","entropyToMnemonic","chainCode","CHAIN_CODE_SIZE","_key","_chainCode","bCurve","computeHmacSha512","segments","isUint32","isValidPath","extendedKey","derivePath","toAddress","RandomSecret","Signature","_signatureCreate","compress","commitment","signatures","_combinePartialSignatures","_signatureVerify","combinedCommitment","partialSignatures","_aggregatePartialSignatures","sigA","sigB","PartialSignature","HALF_SIZE","sA","sB","_scalarsAdd","node_secp256k1_add_scalars","wasmOutSum","wasmInA","wasmInB","_secp256k1_add_scalars","node_secp256k1_schnorr_sign","wasmOutSignature","signatureBuffer","wasmInMessage","wasmInPubKey","wasmInPrivKey","_secp256k1_schnorr_sign","signature","node_secp256k1_schnorr_verify","wasmInSignature","_secp256k1_schnorr_verify","Commitment","commitments","_commitmentsAggregate","concatenatedCommitments","node_secp256k1_aggregate_commitments","wasmInCommitments","_secp256k1_aggregate_commitments","aggCommitments","CommitmentPair","_secret","_commitment","randomness","RANDOMNESS_SIZE","_commitmentCreate","node_secp256k1_create_commitment","wasmOutCommitment","wasmOutSecret","_secp256k1_create_commitment","SERIALIZED_SIZE","aggregateCommitment","_delinearizedPartialSignatureCreate","node_secp256k1_partial_sign","wasmInSecret","wasmInCommitment","_secp256k1_partial_sign","partialSignature","addr","toUserFriendlyAddress","fromUserFriendlyAddress","isBech32Address","Bech32","fromBech32","toBech32","withSpaces","HEX_SIZE","CONTRACT_CREATION","chk","top","GENERATOR","hrp","ret","polymod","hrpExpand","ENCODING","combined","createChecksum","CHARSET","bechString","hasLower","hasUpper","pos","verifyChecksum","fromWidth","toWidth","pad","maxv","address","useHRP","HRP","addrBz","convertBits","bech32Encode","bech32Decode","Account","balance","bigBalance","_balance","TYPE_MAP","writeUint128","fromPlain","plain","transaction","transactionsCache","revert","validityStartHeight","ValidityError","withBalance","fee","newBalance","BalanceError","containsTransaction","DoubleTransactionError","INITIAL","isInitial","proof","BASIC","VESTING","HTLC","ProofError","BasicAccount","readUint128","SignatureProof","verifyTransaction","hasFlag","Transaction","Flag","recipientType","withIncomingTransaction","create","dataToPlain","signatureProof","signer","toPlain","pathLength","merklePath","proofToPlain","Contract","recipient","getContractCreationAddress","HashedTimeLockedContract","sender","hashRoot","hashCount","timeout","totalAmount","bigTotalAmount","_sender","_recipient","_hashRoot","_hashCount","_timeout","_totalAmount","ProofType","REGULAR_TRANSFER","hashDepth","preImage","verify","serializeContent","EARLY_RESOLVE","TIMEOUT_RESOLVE","verifyIncomingTransaction","minCap","isSignedBy","withOutgoingTransaction","creatorSignatureProof","creator","creatorSignature","creatorPublicKey","creatorPathLength","proofType","VestingContract","owner","vestingStart","vestingStepBlocks","vestingStepAmount","vestingTotalAmount","bigVestingStepAmount","bigVestingTotalAmount","_owner","_vestingStart","_vestingStepBlocks","_vestingStepAmount","_vestingTotalAmount","getMinCap","senderType","flags","networkId","GenesisConfig","NETWORK_ID","bigValue","isUint16","_format","_senderType","_recipientType","_value","_fee","txFee","_networkId","_validityStartHeight","_flags","_data","_proof","FORMAT_MAP","serializedContentSize","_valid","_verify","verifyOutgoingTransaction","compareBlockOrder","recCompare","senderCompare","transactionHash","Format","feePerByte","network","networkIdToNetworkName","valid","tx","flag","EXTENDED","NONE","ALL","signerKey","_merklePath","_signature","SINGLE_SIG_SIZE","merkleRoot","computeRoot","BasicTransaction","senderPubKey","singleSig","_signatureProof","that","networkIdFromAny","ExtendedTransaction","dataSize","proofSize","IWorker","clazz","worker","workerScript","_workersSupported","createProxy","Worker","URL","createObjectURL","Blob","_workerImplementation","init","Pool","startWorkerForProxy","command","postMessage","status","areWorkersAsync","_insideWebWorker","WorkerGlobalScope","baseClazz","impl","onmessage","stubBaseOnMessage","setTimeout","onreadystatechange","proxyClass","_name","_messageId","_worker","_receive","_waiting","_invoke","then","cb","delete","WorkerProxy","funcName","getOwnPropertyNames","Stub","finalRes","_result","_onmessage","close","poolClass","proxyInitializer","_proxyInitializer","_poolSize","_workers","_freeWorkers","_waitingCalls","_updateToSize","poolSize","_size","_step","destroy","workerPromises","createdWorkers","idx","_workerAsync","startWorkerPoolForProxy","inputs","iterations","outputSize","block","transactionValid","timeNow","genesisHash","SHA512_BLOCK_SIZE","iKey","oKey","innerHash","derivedKeyLength","hashLength","derivedKey","u","kdfLegacy","xor","kdf","CONFIGS","_config","NETWORK_NAME","keys","main","dev","_loaded","_onload"],"mappings":"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SAAA,SAAA,SAAA,OAAA,SAAA,SAAA,MAAA,MAAA,UAAA,QAAA,QAAA,QAAA,QAAA,QAAA,SAAA,QAAA,SAAA,QAAA,SAAA,QAAA,QAAA,WAAA,SAAA,SAAA,QAAA,UAAA,QAAA,QAAA,SAAA,QAAA,SAAA,UAAA,QAAA,OAAA,OAAA,SAAA,SAAA,SAAA,SAAA,SAAA,QAAA,MAAA,WAAA,OAAA,SAAA,QAAA,OAAA,UAAA,QAAA,QAAA,SAAA,OAAA,OAAA,OAAA,OAAA,SAAA,OAAA,MAAA,QAAA,SAAA,QAAA,SAAA,QAAA,SAAA,SAAA,UAAA,UAAA,UAAA,MAAA,SAAA,OAAA,QAAA,SAAA,QAAA,OAAA,OAAA,OAAA,SAAA,SAAA,SAAA,MAAA,UAAA,QAAA,WAAA,SAAA,SAAA,QAAA,UAAA,OAAA,UAAA,SAAA,SAAA,SAAA,UAAA,SAAA,UAAA,QAAA,QAAA,WAAA,SAAA,QAAA,UAAA,SAAA,QAAA,OAAA,QAAA,QAAA,SAAA,OAAA,SAAA,QAAA,UAAA,QAAA,QAAA,UAAA,SAAA,SAAA,UAAA,UAAA,QAAA,QAAA,QAAA,WAAA,SAAA,UAAA,OAAA,QAAA,QAAA,OAAA,UAAA,OAAA,OAAA,QAAA,QAAA,SAAA,QAAA,SAAA,QAAA,QAAA,SAAA,OAAA,QAAA,OAAA,QAAA,QAAA,QAAA,QAAA,OAAA,QAAA,UAAA,SAAA,QAAA,QAAA,UAAA,OAAA,SAAA,OAAA,OAAA,UAAA,QAAA,SAAA,UAAA,OAAA,UAAA,QAAA,SAAA,UAAA,UAAA,UAAA,UAAA,WAAA,UAAA,WAAA,UAAA,WAAA,OAAA,OAAA,SAAA,OAAA,QAAA,OAAA,OAAA,UAAA,OAAA,SAAA,QAAA,UAAA,SAAA,SAAA,SAAA,QAAA,SAAA,QAAA,SAAA,QAAA,OAAA,QAAA,QAAA,SAAA,QAAA,QAAA,QAAA,SAAA,QAAA,OAAA,UAAA,QAAA,QAAA,SAAA,OAAA,QAAA,SAAA,QAAA,UAAA,QAAA,SAAA,UAAA,SAAA,QAAA,MAAA,UAAA,OAAA,UAAA,MAAA,WAAA,UAAA,UAAA,UAAA,QAAA,UAAA,SAAA,OAAA,QAAA,MAAA,SAAA,OAAA,QAAA,SAAA,SAAA,OAAA,WAAA,OAAA,MAAA,OAAA,SAAA,SAAA,SAAA,WAAA,SAAA,UAAA,WAAA,WAAA,OAAA,UAAA,SAAA,OAAA,SAAA,QAAA,UAAA,SAAA,SAAA,SAAA,UAAA,OAAA,SAAA,SAAA,UAAA,QAAA,SAAA,SAAA,WAAA,SAAA,SAAA,OAAA,UAAA,UAAA,SAAA,SAAA,UAAA,SAAA,SAAA,UAAA,OAAA,UAAA,QAAA,OAAA,SAAA,OAAA,SAAA,UAAA,UAAA,UAAA,SAAA,WAAA,SAAA,OAAA,WAAA,WAAA,UAAA,OAAA,UAAA,WAAA,UAAA,WAAA,SAAA,SAAA,UAAA,QAAA,SAAA,WAAA,MAAA,OAAA,UAAA,SAAA,SAAA,SAAA,QAAA,OAAA,OAAA,SAAA,OAAA,QAAA,SAAA,QAAA,UAAA,OAAA,QAAA,QAAA,QAAA,QAAA,QAAA,OAAA,QAAA,OAAA,OAAA,MAAA,OAAA,OAAA,OAAA,SAAA,OAAA,QAAA,OAAA,QAAA,UAAA,QAAA,QAAA,QAAA,OAAA,QAAA,SAAA,OAAA,OAAA,OAAA,UAAA,UAAA,OAAA,OAAA,UAAA,SAAA,MAAA,QAAA,SAAA,QAAA,QAAA,WAAA,UAAA,UAAA,WAAA,WAAA,QAAA,OAAA,SAAA,SAAA,UAAA,SAAA,UAAA,SAAA,UAAA,QAAA,SAAA,QAAA,MAAA,UAAA,UAAA,QAAA,SAAA,UAAA,SAAA,SAAA,UAAA,QAAA,SAAA,SAAA,SAAA,SAAA,SAAA,QAAA,SAAA,QAAA,WAAA,UAAA,QAAA,QAAA,MAAA,QAAA,QAAA,UAAA,QAAA,QAAA,SAAA,QAAA,UAAA,SAAA,UAAA,SAAA,WAAA,OAAA,QAAA,SAAA,QAAA,UAAA,SAAA,WAAA,SAAA,UAAA,SAAA,UAAA,WAAA,UAAA,UAAA,QAAA,QAAA,OAAA,SAAA,SAAA,SAAA,SAAA,UAAA,SAAA,UAAA,SAAA,QAAA,MAAA,UAAA,SAAA,OAAA,UAAA,OAAA,QAAA,QAAA,OAAA,QAAA,OAAA,SAAA,SAAA,MAAA,QAAA,UAAA,OAAA,UAAA,MAAA,QAAA,SAAA,UAAA,QAAA,WAAA,UAAA,WAAA,UAAA,MAAA,OAAA,OAAA,SAAA,QAAA,WAAA,QAAA,QAAA,MAAA,QAAA,UAAA,QAAA,SAAA,OAAA,OAAA,SAAA,QAAA,OAAA,OAAA,SAAA,SAAA,OAAA,OAAA,QAAA,SAAA,OAAA,MAAA,UAAA,MAAA,OAAA,QAAA,QAAA,OAAA,SAAA,OAAA,SAAA,OAAA,QAAA,QAAA,QAAA,SAAA,QAAA,QAAA,MAAA,OAAA,QAAA,MAAA,OAAA,OAAA,SAAA,OAAA,OAAA,QAAA,SAAA,SAAA,OAAA,UAAA,QAAA,UAAA,SAAA,SAAA,QAAA,MAAA,UAAA,QAAA,WAAA,QAAA,SAAA,SAAA,OAAA,QAAA,QAAA,QAAA,SAAA,QAAA,OAAA,MAAA,QAAA,UAAA,OAAA,SAAA,SAAA,OAAA,SAAA,UAAA,OAAA,MAAA,SAAA,UAAA,SAAA,SAAA,UAAA,MAAA,OAAA,OAAA,SAAA,QAAA,OAAA,UAAA,SAAA,QAAA,SAAA,UAAA,UAAA,QAAA,QAAA,OAAA,SAAA,SAAA,UAAA,OAAA,OAAA,OAAA,SAAA,QAAA,QAAA,QAAA,UAAA,QAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,UAAA,OAAA,OAAA,QAAA,UAAA,SAAA,SAAA,SAAA,OAAA,OAAA,QAAA,QAAA,QAAA,QAAA,QAAA,UAAA,QAAA,QAAA,OAAA,QAAA,OAAA,UAAA,QAAA,OAAA,QAAA,QAAA,QAAA,QAAA,QAAA,SAAA,MAAA,MAAA,QAAA,OAAA,OAAA,SAAA,UAAA,OAAA,QAAA,SAAA,OAAA,QAAA,UAAA,MAAA,OAAA,OAAA,SAAA,OAAA,SAAA,QAAA,QAAA,WAAA,SAAA,QAAA,SAAA,OAAA,MAAA,OAAA,SAAA,OAAA,OAAA,OAAA,MAAA,OAAA,UAAA,QAAA,SAAA,OAAA,OAAA,UAAA,SAAA,OAAA,QAAA,OAAA,OAAA,OAAA,SAAA,QAAA,WAAA,OAAA,QAAA,OAAA,QAAA,MAAA,OAAA,QAAA,SAAA,QAAA,UAAA,SAAA,OAAA,SAAA,QAAA,OAAA,UAAA,SAAA,MAAA,OAAA,OAAA,WAAA,OAAA,SAAA,MAAA,UAAA,UAAA,QAAA,UAAA,UAAA,SAAA,SAAA,SAAA,UAAA,UAAA,OAAA,UAAA,SAAA,WAAA,QAAA,WAAA,SAAA,WAAA,SAAA,UAAA,SAAA,SAAA,UAAA,UAAA,SAAA,SAAA,SAAA,QAAA,WAAA,QAAA,UAAA,SAAA,SAAA,SAAA,UAAA,UAAA,SAAA,WAAA,OAAA,SAAA,SAAA,UAAA,OAAA,SAAA,UAAA,QAAA,OAAA,QAAA,SAAA,SAAA,MAAA,OAAA,UAAA,QAAA,QAAA,QAAA,MAAA,OAAA,OAAA,UAAA,MAAA,QAAA,QAAA,OAAA,SAAA,SAAA,OAAA,OAAA,WAAA,OAAA,OAAA,UAAA,MAAA,OAAA,MAAA,SAAA,OAAA,UAAA,OAAA,MAAA,UAAA,OAAA,SAAA,OAAA,OAAA,QAAA,QAAA,OAAA,MAAA,QAAA,QAAA,SAAA,OAAA,OAAA,OAAA,WAAA,SAAA,QAAA,QAAA,QAAA,QAAA,UAAA,OAAA,MAAA,OAAA,UAAA,QAAA,OAAA,SAAA,OAAA,QAAA,QAAA,UAAA,OAAA,MAAA,QAAA,SAAA,UAAA,QAAA,OAAA,SAAA,OAAA,UAAA,SAAA,SAAA,QAAA,OAAA,UAAA,UAAA,UAAA,OAAA,OAAA,QAAA,OAAA,OAAA,QAAA,OAAA,OAAA,SAAA,OAAA,SAAA,OAAA,SAAA,OAAA,OAAA,UAAA,QAAA,OAAA,QAAA,SAAA,OAAA,OAAA,UAAA,OAAA,SAAA,OAAA,QAAA,QAAA,UAAA,SAAA,QAAA,QAAA,SAAA,SAAA,UAAA,MAAA,QAAA,SAAA,OAAA,OAAA,OAAA,QAAA,OAAA,SAAA,MAAA,SAAA,UAAA,QAAA,UAAA,SAAA,QAAA,SAAA,QAAA,SAAA,SAAA,SAAA,WAAA,OAAA,OAAA,SAAA,QAAA,WAAA,OAAA,SAAA,SAAA,UAAA,OAAA,SAAA,OAAA,UAAA,OAAA,WAAA,QAAA,QAAA,SAAA,OAAA,SAAA,SAAA,UAAA,OAAA,QAAA,QAAA,QAAA,QAAA,OAAA,UAAA,QAAA,SAAA,SAAA,WAAA,OAAA,UAAA,QAAA,OAAA,UAAA,QAAA,SAAA,UAAA,SAAA,SAAA,OAAA,UAAA,MAAA,QAAA,UAAA,SAAA,QAAA,SAAA,MAAA,SAAA,UAAA,SAAA,UAAA,QAAA,OAAA,QAAA,OAAA,UAAA,WAAA,SAAA,SAAA,QAAA,WAAA,QAAA,OAAA,QAAA,OAAA,SAAA,OAAA,WAAA,SAAA,SAAA,WAAA,QAAA,OAAA,SAAA,SAAA,UAAA,OAAA,QAAA,OAAA,SAAA,SAAA,QAAA,SAAA,SAAA,OAAA,OAAA,OAAA,WAAA,UAAA,UAAA,SAAA,QAAA,OAAA,MAAA,UAAA,UAAA,QAAA,OAAA,OAAA,OAAA,QAAA,QAAA,QAAA,UAAA,SAAA,SAAA,QAAA,OAAA,UAAA,OAAA,UAAA,SAAA,QAAA,MAAA,UAAA,SAAA,QAAA,MAAA,MAAA,OAAA,SAAA,SAAA,UAAA,UAAA,SAAA,UAAA,QAAA,QAAA,UAAA,OAAA,MAAA,QAAA,SAAA,QAAA,MAAA,OAAA,MAAA,QAAA,UAAA,OAAA,OAAA,MAAA,QAAA,SAAA,OAAA,OAAA,QAAA,UAAA,SAAA,SAAA,SAAA,QAAA,UAAA,QAAA,WAAA,QAAA,SAAA,WAAA,SAAA,UAAA,QAAA,UAAA,QAAA,SAAA,UAAA,OAAA,OAAA,OAAA,MAAA,QAAA,SAAA,SAAA,QAAA,OAAA,SAAA,OAAA,OAAA,SAAA,OAAA,QAAA,QAAA,QAAA,UAAA,QAAA,SAAA,SAAA,OAAA,SAAA,QAAA,OAAA,QAAA,OAAA,UAAA,SAAA,UAAA,QAAA,OAAA,UAAA,QAAA,SAAA,OAAA,UAAA,UAAA,MAAA,UAAA,SAAA,SAAA,SAAA,UAAA,SAAA,SAAA,MAAA,QAAA,QAAA,SAAA,WAAA,QAAA,SAAA,UAAA,QAAA,MAAA,SAAA,OAAA,QAAA,OAAA,UAAA,OAAA,SAAA,QAAA,QAAA,QAAA,SAAA,UAAA,QAAA,OAAA,SAAA,SAAA,QAAA,OAAA,SAAA,OAAA,OAAA,QAAA,QAAA,OAAA,SAAA,OAAA,OAAA,OAAA,UAAA,UAAA,WAAA,WAAA,OAAA,SAAA,UAAA,UAAA,SAAA,QAAA,WAAA,SAAA,UAAA,SAAA,UAAA,UAAA,SAAA,UAAA,QAAA,QAAA,UAAA,QAAA,WAAA,SAAA,UAAA,QAAA,UAAA,UAAA,UAAA,SAAA,UAAA,UAAA,UAAA,QAAA,WAAA,UAAA,UAAA,QAAA,UAAA,SAAA,UAAA,OAAA,OAAA,QAAA,UAAA,QAAA,QAAA,QAAA,WAAA,SAAA,UAAA,QAAA,OAAA,MAAA,SAAA,UAAA,UAAA,UAAA,UAAA,WAAA,QAAA,OAAA,OAAA,QAAA,SAAA,UAAA,OAAA,OAAA,QAAA,QAAA,OAAA,OAAA,QAAA,QAAA,OAAA,QAAA,SAAA,QAAA,QAAA,OAAA,OAAA,SAAA,QAAA,MAAA,QAAA,QAAA,OAAA,SAAA,QAAA,UAAA,SAAA,UAAA,SAAA,SAAA,UAAA,SAAA,UAAA,SAAA,SAAA,SAAA,SAAA,UAAA,SAAA,QAAA,UAAA,SAAA,OAAA,SAAA,WAAA,SAAA,SAAA,SAAA,QAAA,OAAA,SAAA,SAAA,SAAA,UAAA,SAAA,UAAA,SAAA,WAAA,SAAA,WAAA,WAAA,SAAA,SAAA,UAAA,SAAA,UAAA,SAAA,SAAA,SAAA,SAAA,MAAA,SAAA,OAAA,OAAA,OAAA,QAAA,QAAA,QAAA,QAAA,OAAA,OAAA,SAAA,OAAA,SAAA,QAAA,QAAA,OAAA,QAAA,QAAA,SAAA,SAAA,UAAA,OAAA,SAAA,OAAA,OAAA,SAAA,QAAA,QAAA,QAAA,QAAA,SAAA,OAAA,MAAA,OAAA,MAAA,SAAA,QAAA,MAAA,SAAA,UAAA,OAAA,OAAA,QAAA,SAAA,QAAA,OAAA,SAAA,OAAA,SAAA,OAAA,UAAA,UAAA,QAAA,UAAA,OAAA,MAAA,QAAA,OAAA,QAAA,UAAA,QAAA,SAAA,SAAA,UAAA,WAAA,WAAA,QAAA,QAAA,SAAA,SAAA,QAAA,MAAA,SAAA,SAAA,OAAA,SAAA,SAAA,UAAA,WAAA,OAAA,OAAA,UAAA,SAAA,OAAA,UAAA,SAAA,QAAA,WAAA,SAAA,UAAA,UAAA,SAAA,QAAA,QAAA,SAAA,QAAA,UAAA,QAAA,OAAA,QAAA,UAAA,SAAA,QAAA,QAAA,OAAA,SAAA,QAAA,OAAA,QAAA,OAAA,QAAA,WAAA,QAAA,SAAA,QAAA,UAAA,MAAA,UAAA,OAAA,OAAA,QAAA,QAAA,OAAA,SAAA,OAAA,QAAA,SAAA,UAAA,SAAA,QAAA,OAAA,QAAA,SAAA,UAAA,MAAA,OAAA,QAAA,SAAA,MAAA,QAAA,OAAA,QAAA,QAAA,OAAA,OAAA,QAAA,UAAA,QAAA,QAAA,SAAA,OAAA,SAAA,OAAA,OAAA,QAAA,QAAA,QAAA,QAAA,QAAA,SAAA,QAAA,QAAA,OAAA,QAAA,OAAA,OAAA,SAAA,SAAA,OAAA,OAAA,OAAA,QAAA,UAAA,QAAA,WAAA,QAAA,UAAA,OAAA,OAAA,QAAA,OAAA,OAAA,QAAA,OAAA,SAAA,QAAA,QAAA,QAAA,UAAA,QAAA,QAAA,UAAA,QAAA,QAAA,QAAA,SAAA,QAAA,SAAA,QAAA,OAAA,SAAA,QAAA,QAAA,UAAA,QAAA,QAAA,OAAA,QAAA,SAAA,SAAA,MAAA,SAAA,UAAA,WAAA,SAAA,UAAA,QAAA,QAAA,SAAA,QAAA,QAAA,QAAA,QAAA,OAAA,QAAA,QAAA,OAAA,OAAA,SAAA,QAAA,QAAA,QAAA,QAAA,UAAA,QAAA,QAAA,QAAA,QAAA,WAAA,SAAA,SAAA,SAAA,WAAA,UAAA,QAAA,UAAA,QAAA,UAAA,SAAA,SAAA,UAAA,OAAA,SAAA,SAAA,QAAA,UAAA,OAAA,SAAA,MAAA,QAAA,SAAA,QAAA,SAAA,UAAA,OAAA,UAAA,QAAA,WAAA,WAAA,SAAA,UAAA,UAAA,UAAA,QAAA,OAAA,QAAA,QAAA,QAAA,QAAA,OAAA,QAAA,SAAA,QAAA,SAAA,UAAA,QAAA,SAAA,QAAA,SAAA,MAAA,OAAA,SAAA,OAAA,OAAA,OAAA,SAAA,OAAA,QAAA,SAAA,OAAA,QAAA,OAAA,OAAA,MAAA,SAAA,SAAA,OAAA,OAAA,OAAA,OAAA,QAAA,OAAA,QAAA,OAAA,SAAA,QAAA,OAAA,QAAA,OAAA,UAAA,QAAA,SAAA,QAAA,QAAA,UAAA,SAAA,OAAA,QAAA,OAAA,SAAA,OAAA,OAAA,MAAA,QAAA,SAAA,QAAA,QAAA,UAAA,QAAA,UAAA,MAAA,WAAA,SAAA,QAAA,SAAA,WAAA,OAAA,SAAA,UAAA,OAAA,QAAA,MAAA,QAAA,SAAA,QAAA,UAAA,WAAA,OAAA,QAAA,UAAA,SAAA,QAAA,OAAA,MAAA,QAAA,QAAA,UAAA,SAAA,QAAA,WAAA,OAAA,QAAA,SAAA,OAAA,QAAA,OAAA,QAAA,QAAA,QAAA,QAAA,UAAA,OAAA,OAAA,SAAA,UAAA,QAAA,OAAA,QAAA,UAAA,QAAA,QAAA,MAAA,OAAA,UAAA,SAAA,OAAA,SAAA,SAAA,OAAA,SAAA,SAAA,SAAA,QAAA,OAAA,QAAA,MAAA,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","file":"web-offline.js","sourcesContent":["if (typeof Krypton === 'undefined') {\r\n var Krypton = typeof window !== 'undefined' ? window : {};\r\n}\r\nvar Proxy; // ensure Proxy exists\r\n(function (exports) {\r\n exports = typeof exports !== 'undefined' ? exports : {};\r\n Krypton = exports;\r\n if (!Krypton._currentScript) {\r\n Krypton._currentScript = document.currentScript;\r\n }\r\n if (!Krypton._currentScript) {\r\n // Heuristic\r\n const scripts = document.getElementsByTagName('script');\r\n Krypton._currentScript = scripts[scripts.length - 1];\r\n }\r\n if (!Krypton._path) {\r\n if (Krypton._currentScript && Krypton._currentScript.src.indexOf('/') !== -1) {\r\n Krypton._path = Krypton._currentScript.src.substring(0, Krypton._currentScript.src.lastIndexOf('/') + 1);\r\n } else {\r\n // Fallback\r\n Krypton._path = './';\r\n }\r\n }\r\n","class Class {\r\n static get scope() {\r\n if (typeof exports !== 'undefined') return exports;\r\n if (typeof self !== 'undefined') return self;\r\n return window;\r\n }\r\n\r\n static register(cls) {\r\n if (typeof exports !== 'undefined') exports[cls.name] = cls;\r\n }\r\n}\r\nClass.register(Class);\r\n","class LogNative {\r\n constructor() {\r\n this._global_level = Log.INFO;\r\n this._tag_levels = {};\r\n try {\r\n if (window.localStorage) {\r\n try {\r\n let c = window.localStorage.getItem('log_tag_levels');\r\n if (c && typeof c === 'string') c = JSON.parse(c);\r\n if (c && typeof c === 'object') this._tag_levels = c;\r\n } catch (e) {\r\n console.warn('Failed to load log configuration from local storage.');\r\n }\r\n }\r\n } catch (e) {\r\n // ignore\r\n }\r\n }\r\n\r\n isLoggable(tag, level) {\r\n if (tag && this._tag_levels[tag]) {\r\n return this._tag_levels[tag] <= level;\r\n }\r\n if (this._tag_levels['*']) {\r\n return this._tag_levels['*'] <= level;\r\n }\r\n return this._global_level <= level;\r\n }\r\n\r\n setLoggable(tag, level) {\r\n if (tag && tag.name) tag = tag.name;\r\n this._tag_levels[tag] = level;\r\n if (window.localStorage) {\r\n window.localStorage.setItem('log_tag_levels', JSON.stringify(this._tag_levels));\r\n }\r\n }\r\n\r\n msg(level, tag, args) {\r\n if (tag && tag.name) tag = tag.name;\r\n if (!this.isLoggable(tag, level)) return;\r\n if (tag) args.unshift(tag + ':');\r\n args.unshift(`[${Log.Level.toStringTag(level)} ${new Date().toTimeString().substr(0, 8)}]`);\r\n if (console.error && level >= Log.ERROR) {\r\n console.error.apply(console, args);\r\n } else if (console.warn && level >= Log.WARNING) {\r\n console.warn.apply(console, args);\r\n } else if (console.info && level >= Log.INFO) {\r\n console.info.apply(console, args);\r\n } else if (console.debug && level >= Log.DEBUG) {\r\n console.debug.apply(console, args);\r\n } else if (console.trace && level <= Log.TRACE) {\r\n console.trace.apply(console, args);\r\n } else {\r\n console.log.apply(console, args);\r\n }\r\n }\r\n}\r\nClass.register(LogNative);\r\n","class Log {\r\n /**\r\n * @returns {Log}\r\n */\r\n static get instance() {\r\n if (!Log._instance) {\r\n Log._instance = new Log(new LogNative());\r\n }\r\n return Log._instance;\r\n }\r\n\r\n /**\r\n * @param {LogNative} native\r\n */\r\n constructor(native) {\r\n /** @type {LogNative} */\r\n this._native = native;\r\n }\r\n\r\n /**\r\n * @param {string} tag\r\n * @param {Log.Level} level\r\n */\r\n setLoggable(tag, level) {\r\n this._native.setLoggable(tag, Log.Level.get(level));\r\n }\r\n\r\n /** @type {Log.Level} */\r\n get level() {\r\n return this._native._global_level;\r\n }\r\n\r\n /** @type {Log.Level} */\r\n set level(l) {\r\n this._native._global_level = Log.Level.get(l);\r\n }\r\n\r\n /**\r\n * @param {Log.Level} level\r\n * @param {string|{name:string}} tag\r\n * @param {Array} args\r\n */\r\n msg(level, tag, args) {\r\n if (this._native.isLoggable(tag, level)) {\r\n for (let i = 0; i < args.length; ++i) {\r\n if (typeof args[i] === 'function') {\r\n args[i] = args[i]();\r\n }\r\n if (typeof args[i] === 'object') {\r\n if (typeof args[i].toString === 'function') {\r\n args[i] = args[i].toString();\r\n } else if (args[i].constructor && args[i].constructor.name) {\r\n args[i] = `{Object: ${args[i].constructor.name}}`;\r\n } else {\r\n args[i] = '{Object}';\r\n }\r\n }\r\n }\r\n this._native.msg(level, tag, args);\r\n }\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static d(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.DEBUG, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static e(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.ERROR, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static i(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.INFO, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static v(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.VERBOSE, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static w(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.WARNING, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static t(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.TRACE, tag, args);\r\n }\r\n}\r\n\r\n/**\r\n * @enum {number|string}\r\n */\r\nLog.Level = {\r\n TRACE: 1,\r\n VERBOSE: 2,\r\n DEBUG: 3,\r\n INFO: 4,\r\n WARNING: 5,\r\n ERROR: 6,\r\n ASSERT: 7,\r\n\r\n /**\r\n * @param {Log.Level} level\r\n * @returns {string}\r\n */\r\n toStringTag: function (level) {\r\n switch (level) {\r\n case Log.Level.TRACE:\r\n return 'T';\r\n case Log.Level.VERBOSE:\r\n return 'V';\r\n case Log.Level.DEBUG:\r\n return 'D';\r\n case Log.Level.INFO:\r\n return 'I';\r\n case Log.Level.WARNING:\r\n return 'W';\r\n case Log.Level.ERROR:\r\n return 'E';\r\n case Log.Level.ASSERT:\r\n return 'A';\r\n default:\r\n return '*';\r\n }\r\n },\r\n\r\n toString: function (level) {\r\n switch (level) {\r\n case Log.Level.TRACE:\r\n return 'trace';\r\n case Log.Level.VERBOSE:\r\n return 'verbose';\r\n case Log.Level.DEBUG:\r\n return 'debug';\r\n case Log.Level.INFO:\r\n return 'info';\r\n case Log.Level.WARNING:\r\n return 'warn';\r\n case Log.Level.ERROR:\r\n return 'error';\r\n case Log.Level.ASSERT:\r\n return 'assert';\r\n default:\r\n return 'unknown';\r\n }\r\n },\r\n\r\n /**\r\n * @param {string|number|Log.Level} v\r\n * @returns {Log.Level}\r\n */\r\n get: function (v) {\r\n if (typeof v === 'number') return /** @type {Log.Level} */ v;\r\n if (!isNaN(parseInt(v))) return /** @type {Log.Level} */ parseInt(v);\r\n switch (v.toLowerCase()) {\r\n case 't':\r\n case 'trace':\r\n return Log.Level.TRACE;\r\n case 'v':\r\n case 'verbose':\r\n return Log.Level.VERBOSE;\r\n case 'd':\r\n case 'debug':\r\n return Log.Level.DEBUG;\r\n case 'i':\r\n case 'info':\r\n return Log.Level.INFO;\r\n case 'w':\r\n case 'warn':\r\n case 'warning':\r\n return Log.Level.WARNING;\r\n case 'e':\r\n case 'error':\r\n case 'exception':\r\n return Log.Level.ERROR;\r\n case 'a':\r\n case 'assert':\r\n case 'assertion':\r\n return Log.Level.ASSERT;\r\n }\r\n return /** @type {Log.Level} */ 0;\r\n }\r\n};\r\nLog.TRACE = Log.Level.TRACE;\r\nLog.VERBOSE = Log.Level.VERBOSE;\r\nLog.DEBUG = Log.Level.DEBUG;\r\nLog.INFO = Log.Level.INFO;\r\nLog.WARNING = Log.Level.WARNING;\r\nLog.ERROR = Log.Level.ERROR;\r\nLog.ASSERT = Log.Level.ASSERT;\r\nLog._instance = null;\r\n\r\nLog.d.tag = (tag) => Log.d.bind(null, tag);\r\nLog.e.tag = (tag) => Log.e.bind(null, tag);\r\nLog.i.tag = (tag) => Log.i.bind(null, tag);\r\nLog.v.tag = (tag) => Log.v.bind(null, tag);\r\nLog.w.tag = (tag) => Log.w.bind(null, tag);\r\nLog.t.tag = (tag) => Log.t.bind(null, tag);\r\n\r\nClass.register(Log);\r\n","class Observable {\r\n /**\r\n * @returns {string}\r\n * @constant\r\n */\r\n static get WILDCARD() {\r\n return '*';\r\n }\r\n\r\n constructor() {\r\n /** @type {Map.<string, Array.<Function>>} */\r\n this._listeners = new Map();\r\n }\r\n\r\n _offAll() {\r\n this._listeners.clear();\r\n }\r\n\r\n /**\r\n * @param {string} type\r\n * @param {Function} callback\r\n * @return {number}\r\n */\r\n on(type, callback) {\r\n if (!this._listeners.has(type)) {\r\n this._listeners.set(type, [callback]);\r\n return 0;\r\n } else {\r\n return this._listeners.get(type).push(callback) - 1;\r\n }\r\n }\r\n\r\n /**\r\n * @param {string} type\r\n * @param {number} id\r\n */\r\n off(type, id) {\r\n if (!this._listeners.has(type) || !this._listeners.get(type)[id]) return;\r\n delete this._listeners.get(type)[id];\r\n }\r\n\r\n /**\r\n * @param {string} type\r\n * @param {...*} args\r\n * @returns {?Promise}\r\n */\r\n fire(type, ...args) {\r\n const promises = [];\r\n\r\n // Notify listeners for this event type.\r\n if (this._listeners.has(type)) {\r\n const listeners = this._listeners.get(type);\r\n for (const key in listeners) {\r\n if (!listeners.hasOwnProperty(key)) continue;\r\n try {\r\n const res = listeners[key].apply(null, args);\r\n if (res instanceof Promise) {\r\n promises.push(res.catch(e => Log.e(this.constructor.name,\r\n `Exception thrown by '${type}' listener #${key}: ${e.message || e}`, e)));\r\n }\r\n } catch (e) {\r\n Log.e(this.constructor.name,\r\n `Exception thrown by '${type}' listener #${key}: ${e.message || e}`, e);\r\n }\r\n }\r\n }\r\n\r\n // Notify wildcard listeners. Pass event type as first argument.\r\n if (this._listeners.has(Observable.WILDCARD)) {\r\n const listeners = this._listeners.get(Observable.WILDCARD);\r\n for (const key in listeners) {\r\n if (!listeners.hasOwnProperty(key)) continue;\r\n try {\r\n const res = listeners[key].apply(null, arguments);\r\n if (res instanceof Promise) {\r\n promises.push(res.catch(e => Log.e(this.constructor.name,\r\n `Exception thrown by '${type}' wildcard listener #${key}: ${e.message || e}`, e)));\r\n }\r\n } catch (e) {\r\n Log.e(this.constructor.name,\r\n `Exception thrown by '${type}' wildcard listener #${key}: ${e.message || e}`, e);\r\n }\r\n }\r\n }\r\n\r\n if (promises.length > 0) return Promise.all(promises);\r\n return null;\r\n }\r\n\r\n /**\r\n * @param {Observable} observable\r\n * @param {...string} types\r\n */\r\n bubble(observable, ...types) {\r\n for (const type of types) {\r\n let callback;\r\n if (type === Observable.WILDCARD) {\r\n callback = function() {\r\n this.fire.apply(this, arguments);\r\n };\r\n } else {\r\n callback = function() {\r\n this.fire.apply(this, [type, ...arguments]);\r\n };\r\n }\r\n observable.on(type, callback.bind(this));\r\n }\r\n }\r\n}\r\nClass.register(Observable);\r\n","class CryptoLib {\r\n /**\r\n * @return {SubtleCrypto|*}\r\n */\r\n static get instance() {\r\n if (!CryptoLib._instance) {\r\n const instance = {};\r\n instance.getRandomValues = (window.crypto || window.msCrypto).getRandomValues.bind(window.crypto);\r\n\r\n CryptoLib._instance = instance;\r\n }\r\n return CryptoLib._instance;\r\n }\r\n}\r\nCryptoLib._instance = null;\r\nClass.register(CryptoLib);\r\n","class PlatformUtils {\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isBrowser() {\r\n return true;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isWeb() {\r\n return typeof window !== 'undefined';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isNodeJs() {\r\n return false;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static supportsWebRTC() {\r\n const RTCPeerConnection = PlatformUtils.isBrowser() ? (window.RTCPeerConnection || window.webkitRTCPeerConnection) : null;\r\n return !!RTCPeerConnection && typeof RTCPeerConnection.prototype.createDataChannel === 'function';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static supportsWS() {\r\n return location && location.protocol === 'http:';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isOnline() {\r\n return !('onLine' in window.navigator) || window.navigator.onLine;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isWindows() {\r\n return /^win/.test(window.navigator.platform);\r\n }\r\n\r\n static get userAgentString() {\r\n try {\r\n return window.navigator.platform;\r\n } catch (e) {\r\n return 'unknown';\r\n }\r\n }\r\n\r\n static get hardwareConcurrency() {\r\n if (typeof navigator === 'object' && navigator.hardwareConcurrency) {\r\n return navigator.hardwareConcurrency;\r\n } else {\r\n return 1;\r\n }\r\n }\r\n}\r\n\r\nClass.register(PlatformUtils);\r\n","class WasmHelper {\r\n\r\n static async doImport() {\r\n return WasmHelper.doImportBrowser();\r\n }\r\n\r\n static async doImportBrowser() {\r\n WasmHelper._importBrowserPromise = WasmHelper._importBrowserPromise || (async () => {\r\n if (await WasmHelper.importWasmBrowser('worker-wasm.wasm')) {\r\n await WasmHelper.importScriptBrowser('worker-wasm.js', 'Module', 'sha256-Pbm9dyLcorY4zzI5YHfcFL2c8cVh2AJOIsxqa3ceOp4=');\r\n } else {\r\n await WasmHelper.importScriptBrowser('worker-js.js', 'Module', 'sha256-Ym7/F/nwZ7ZVkZcFF1RSK0M0DhYBfB+lQHiEJ1N9lgI=');\r\n }\r\n })();\r\n try {\r\n await WasmHelper._importBrowserPromise;\r\n } catch (e) {\r\n WasmHelper._importBrowserPromise = null;\r\n throw e;\r\n }\r\n }\r\n\r\n /**\r\n * @param {string} wasm\r\n * @param {string} module\r\n * @returns {Promise.<boolean>}\r\n */\r\n static async importWasm(wasm, module = 'Module') {\r\n return WasmHelper.importWasmBrowser(wasm, module);\r\n }\r\n\r\n /**\r\n * @param {string} wasm\r\n * @param {string} module\r\n * @returns {Promise.<boolean>}\r\n */\r\n static async importWasmBrowser(wasm, module = 'Module') {\r\n wasm = WasmHelper._adjustWasmPath(wasm);\r\n if (!WasmHelper._global.WebAssembly) {\r\n Log.w(WasmHelper, 'No support for WebAssembly available.');\r\n return Promise.resolve(false);\r\n }\r\n\r\n return new Promise((resolve) => {\r\n try {\r\n const xhr = new XMLHttpRequest();\r\n xhr.open('GET', wasm, true);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.onload = function () {\r\n WasmHelper._global[module] = WasmHelper._global[module] || {};\r\n WasmHelper._global[module].wasmBinary = xhr.response;\r\n resolve(true);\r\n };\r\n xhr.onerror = function () {\r\n Log.w(WasmHelper, `Failed to access WebAssembly module ${wasm}`);\r\n resolve(false);\r\n };\r\n xhr.send(null);\r\n } catch (e) {\r\n Log.w(WasmHelper, `Failed to access WebAssembly module ${wasm}`);\r\n resolve(false);\r\n }\r\n });\r\n }\r\n\r\n static async importScript(script, module = 'Module') {\r\n return WasmHelper.importScriptBrowser(script, module);\r\n }\r\n\r\n static async importScriptBrowser(script, module = 'Module', integrity=null) {\r\n if (module && WasmHelper._global[module] && WasmHelper._global[module].asm) return false;\r\n script = WasmHelper._adjustScriptPath(script);\r\n\r\n const moduleSettings = WasmHelper._global[module] || {};\r\n return new Promise(async (resolve, reject) => {\r\n const runtimeInitialized = new Promise((resolve) => {\r\n moduleSettings.onRuntimeInitialized = () => resolve(true);\r\n });\r\n if (typeof importScripts === 'function') {\r\n await new Promise((resolve) => {\r\n WasmHelper._moduleLoadedCallbacks[module] = resolve;\r\n importScripts(script);\r\n });\r\n WasmHelper._global[module] = WasmHelper._global[module](moduleSettings);\r\n } else if (typeof window === 'object') {\r\n await new Promise((resolve) => {\r\n WasmHelper._moduleLoadedCallbacks[module] = resolve;\r\n WasmHelper._loadBrowserScript(script, integrity);\r\n });\r\n WasmHelper._global[module] = WasmHelper._global[module](moduleSettings);\r\n } else if (typeof require === 'function') {\r\n WasmHelper._global[module] = require(script)(moduleSettings);\r\n } else {\r\n reject('No way to load scripts.');\r\n return;\r\n }\r\n await runtimeInitialized;\r\n if (moduleSettings.asm && !WasmHelper._global[module].asm) WasmHelper._global[module] = moduleSettings;\r\n resolve(true);\r\n });\r\n }\r\n\r\n static fireModuleLoaded(module = 'Module') {\r\n if (typeof WasmHelper._moduleLoadedCallbacks[module] === 'function') {\r\n WasmHelper._moduleLoadedCallbacks[module]();\r\n WasmHelper._moduleLoadedCallbacks[module] = null;\r\n }\r\n }\r\n\r\n static _loadBrowserScript(url, integrity) {\r\n const head = document.getElementsByTagName('head')[0];\r\n const script = document.createElement('script');\r\n script.type = 'text/javascript';\r\n script.src = url;\r\n if (integrity != null) {\r\n script.integrity = integrity;\r\n script.crossOrigin = 'anonymous';\r\n }\r\n head.appendChild(script);\r\n }\r\n\r\n static _adjustWasmPath(wasm) {\r\n if (typeof Krypton !== 'undefined' && Krypton._path) wasm = `${Krypton._path}${wasm}`;\r\n if (typeof __dirname === 'string' && wasm.indexOf('/') === -1) wasm = `${__dirname}/${wasm}`;\r\n return wasm;\r\n }\r\n\r\n static _adjustScriptPath(script) {\r\n if (typeof Krypton !== 'undefined' && Krypton._path) script = `${Krypton._path}${script}`;\r\n if (typeof __dirname === 'string' && script.indexOf('/') === -1) script = `${__dirname}/${script}`;\r\n return script;\r\n }\r\n\r\n static get _global() {\r\n return typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : null;\r\n }\r\n}\r\n\r\nWasmHelper._moduleLoadedCallbacks = {};\r\n\r\nClass.register(WasmHelper);\r\n","class ArrayUtils {\r\n /**\r\n * @template T\r\n * @param {Array.<T>} arr\r\n * @return {T}\r\n */\r\n static randomElement(arr) {\r\n return arr[Math.floor(Math.random() * arr.length)];\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} uintarr\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @return {Uint8Array}\r\n */\r\n static subarray(uintarr, begin, end) {\r\n function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }\r\n\r\n if (begin === undefined) { begin = 0; }\r\n if (end === undefined) { end = uintarr.byteLength; }\r\n\r\n begin = clamp(begin, 0, uintarr.byteLength);\r\n end = clamp(end, 0, uintarr.byteLength);\r\n\r\n let len = end - begin;\r\n if (len < 0) {\r\n len = 0;\r\n }\r\n\r\n return new Uint8Array(uintarr.buffer, uintarr.byteOffset + begin, len);\r\n }\r\n\r\n /**\r\n * @param {Array} list\r\n * @param {number} k\r\n * @yields {Array}\r\n */\r\n static *k_combinations(list, k) {\r\n const n = list.length;\r\n // Shortcut:\r\n if (k > n) {\r\n return;\r\n }\r\n const indices = Array.from(new Array(k), (x,i) => i);\r\n yield indices.map(i => list[i]);\r\n const reverseRange = Array.from(new Array(k), (x,i) => k-i-1);\r\n /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\r\n while (true) {\r\n let i = k-1, found = false;\r\n for (i of reverseRange) {\r\n if (indices[i] !== i + n - k) {\r\n found = true;\r\n break;\r\n }\r\n }\r\n if (!found) {\r\n return;\r\n }\r\n indices[i] += 1;\r\n for (const j of Array.from(new Array(k-i-1), (x,k) => i+k+1)) {\r\n indices[j] = indices[j-1] + 1;\r\n }\r\n yield indices.map(i => list[i]);\r\n }\r\n }\r\n}\r\nClass.register(ArrayUtils);\r\n","class Assert {\r\n /**\r\n * @param {boolean} condition\r\n * @param {string} [message]\r\n * @returns {void}\r\n */\r\n static that(condition, message = 'Assertion failed') {\r\n if (!condition) {\r\n throw new Error(message);\r\n }\r\n }\r\n}\r\nClass.register(Assert);\r\n","class BufferUtils {\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toAscii(buffer) {\r\n const chunkSize = 0x2000;\r\n const buf = BufferUtils._toUint8View(buffer);\r\n\r\n let ascii = '';\r\n for (let i = 0; i < buf.length; i += chunkSize) {\r\n ascii += String.fromCharCode.apply(null, buf.subarray(i, i + chunkSize));\r\n }\r\n return ascii;\r\n }\r\n\r\n /**\r\n * @param {string} string\r\n * @return {Uint8Array}\r\n */\r\n static fromAscii(string) {\r\n const buf = new Uint8Array(string.length);\r\n for (let i = 0; i < string.length; ++i) {\r\n buf[i] = string.charCodeAt(i);\r\n }\r\n return buf;\r\n }\r\n\r\n static _codePointTextDecoder(buffer) {\r\n if (typeof TextDecoder === 'undefined') throw new Error('TextDecoder not supported');\r\n if (BufferUtils._ISO_8859_15_DECODER === null) throw new Error('TextDecoder does not support iso-8859-15');\r\n if (BufferUtils._ISO_8859_15_DECODER === undefined) {\r\n try {\r\n BufferUtils._ISO_8859_15_DECODER = new TextDecoder('iso-8859-15');\r\n } catch (e) {\r\n BufferUtils._ISO_8859_15_DECODER = null;\r\n throw new Error('TextDecoder does not support iso-8859-15');\r\n }\r\n }\r\n const uint8View = BufferUtils._toUint8View(buffer);\r\n return BufferUtils._ISO_8859_15_DECODER.decode(uint8View)\r\n .replace(/\\u20ac/g, '\\u00a4') // € => ¤\r\n .replace(/\\u0160/g, '\\u00a6') // Š => ¦\r\n .replace(/\\u0161/g, '\\u00a8') // š => ¨\r\n .replace(/\\u017d/g, '\\u00b4') // Ž => ´\r\n .replace(/\\u017e/g, '\\u00b8') // ž => ¸\r\n .replace(/\\u0152/g, '\\u00bc') // Œ => ¼\r\n .replace(/\\u0153/g, '\\u00bd') // œ => ½\r\n .replace(/\\u0178/g, '\\u00be'); // Ÿ => ¾\r\n }\r\n\r\n static _tripletToBase64(num) {\r\n return BufferUtils._BASE64_LOOKUP[num >> 18 & 0x3F] + BufferUtils._BASE64_LOOKUP[num >> 12 & 0x3F] + BufferUtils._BASE64_LOOKUP[num >> 6 & 0x3F] + BufferUtils._BASE64_LOOKUP[num & 0x3F];\r\n }\r\n\r\n static _base64encodeChunk(u8, start, end) {\r\n let tmp;\r\n const output = [];\r\n for (let i = start; i < end; i += 3) {\r\n tmp = ((u8[i] << 16) & 0xFF0000) + ((u8[i + 1] << 8) & 0xFF00) + (u8[i + 2] & 0xFF);\r\n output.push(BufferUtils._tripletToBase64(tmp));\r\n }\r\n return output.join('');\r\n }\r\n\r\n static _base64fromByteArray(u8) {\r\n let tmp;\r\n const len = u8.length;\r\n const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\r\n let output = '';\r\n const parts = [];\r\n const maxChunkLength = 16383; // must be multiple of 3\r\n\r\n // go through the array every three bytes, we'll deal with trailing stuff later\r\n for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\r\n parts.push(BufferUtils._base64encodeChunk(u8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));\r\n }\r\n\r\n // pad the end with zeros, but make sure to not forget the extra bytes\r\n if (extraBytes === 1) {\r\n tmp = u8[len - 1];\r\n output += BufferUtils._BASE64_LOOKUP[tmp >> 2];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp << 4) & 0x3F];\r\n output += '==';\r\n } else if (extraBytes === 2) {\r\n tmp = (u8[len - 2] << 8) + (u8[len - 1]);\r\n output += BufferUtils._BASE64_LOOKUP[tmp >> 10];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp >> 4) & 0x3F];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp << 2) & 0x3F];\r\n output += '=';\r\n }\r\n\r\n parts.push(output);\r\n\r\n return parts.join('');\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBase64(buffer) {\r\n if (PlatformUtils.isNodeJs()) {\r\n return Buffer.from(buffer).toString('base64');\r\n } else if (typeof TextDecoder !== 'undefined' && BufferUtils._ISO_8859_15_DECODER !== null) {\r\n try {\r\n return btoa(BufferUtils._codePointTextDecoder(buffer));\r\n } catch (e) {\r\n // Disabled itself\r\n }\r\n }\r\n\r\n return BufferUtils._base64fromByteArray(BufferUtils._toUint8View(buffer));\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromBase64(base64, length) {\r\n const arr = new Uint8Array(atob(base64).split('').map(c => c.charCodeAt(0)));\r\n if (length !== undefined && arr.length !== length) throw new Error('Decoded length does not match expected length');\r\n return new SerialBuffer(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBase64Url(buffer) {\r\n return BufferUtils.toBase64(buffer).replace(/\\//g, '_').replace(/\\+/g, '-').replace(/=/g, '.');\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromBase64Url(base64, length) {\r\n return BufferUtils.fromBase64(base64.replace(/_/g, '/').replace(/-/g, '+').replace(/\\./g, '='), length);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase32(buf, alphabet = BufferUtils.BASE32_ALPHABET.KRYPTON) {\r\n let shift = 3, carry = 0, byte, symbol, i, res = '';\r\n\r\n for (i = 0; i < buf.length; i++) {\r\n byte = buf[i];\r\n symbol = carry | (byte >> shift);\r\n res += alphabet[symbol & 0x1f];\r\n\r\n if (shift > 5) {\r\n shift -= 5;\r\n symbol = byte >> shift;\r\n res += alphabet[symbol & 0x1f];\r\n }\r\n\r\n shift = 5 - shift;\r\n carry = byte << shift;\r\n shift = 8 - shift;\r\n }\r\n\r\n if (shift !== 3) {\r\n res += alphabet[carry & 0x1f];\r\n }\r\n\r\n while (res.length % 8 !== 0 && alphabet.length === 33) {\r\n res += alphabet[32];\r\n }\r\n\r\n return res;\r\n }\r\n\r\n /**\r\n * @param {string} base32\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase32(base32, alphabet = BufferUtils.BASE32_ALPHABET.KRYPTON) {\r\n const charmap = [];\r\n alphabet.toUpperCase().split('').forEach((c, i) => {\r\n if (!(c in charmap)) charmap[c] = i;\r\n });\r\n\r\n let symbol, shift = 8, carry = 0, buf = [];\r\n base32.toUpperCase().split('').forEach((char) => {\r\n // ignore padding\r\n if (alphabet.length === 33 && char === alphabet[32]) return;\r\n\r\n symbol = charmap[char] & 0xff;\r\n\r\n shift -= 5;\r\n if (shift > 0) {\r\n carry |= symbol << shift;\r\n } else if (shift < 0) {\r\n buf.push(carry | (symbol >> -shift));\r\n shift += 8;\r\n carry = (symbol << shift) & 0xff;\r\n } else {\r\n buf.push(carry | symbol);\r\n shift = 8;\r\n carry = 0;\r\n }\r\n });\r\n\r\n if (shift !== 8 && carry !== 0) {\r\n buf.push(carry);\r\n }\r\n\r\n return new Uint8Array(buf);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toHex(buffer) {\r\n let hex = '';\r\n for (let i = 0; i < buffer.length; i++) {\r\n const code = buffer[i];\r\n hex += BufferUtils.HEX_ALPHABET[code >>> 4];\r\n hex += BufferUtils.HEX_ALPHABET[code & 0x0F];\r\n }\r\n return hex;\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromHex(hex, length) {\r\n hex = hex.trim();\r\n if (!StringUtils.isHexBytes(hex, length)) throw new Error('String is not an hex string (of matching length)');\r\n return new SerialBuffer(new Uint8Array((hex.match(/.{2}/g) || []).map(byte => parseInt(byte, 16))));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBinary(buffer) {\r\n let bin = '';\r\n for (let i = 0; i < buffer.length; i++) {\r\n const code = buffer[i];\r\n bin += StringUtils.lpad(code.toString(2), '0', 8);\r\n }\r\n return bin;\r\n }\r\n\r\n /**\r\n * Taken from https://github.com/google/closure-library/blob/master/closure/goog/crypt/crypt.js.\r\n *\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _strToUint8Array(str) {\r\n const out = [];\r\n let p = 0;\r\n for (let i = 0; i < str.length; i++) {\r\n let c = str.charCodeAt(i);\r\n if (c < 128) {\r\n out[p++] = c;\r\n } else if (c < 2048) {\r\n out[p++] = (c >> 6) | 192;\r\n out[p++] = (c & 63) | 128;\r\n } else if (\r\n ((c & 0xFC00) === 0xD800) && (i + 1) < str.length &&\r\n ((str.charCodeAt(i + 1) & 0xFC00) === 0xDC00)) {\r\n // Surrogate Pair\r\n c = 0x10000 + ((c & 0x03FF) << 10) + (str.charCodeAt(++i) & 0x03FF);\r\n out[p++] = (c >> 18) | 240;\r\n out[p++] = ((c >> 12) & 63) | 128;\r\n out[p++] = ((c >> 6) & 63) | 128;\r\n out[p++] = (c & 63) | 128;\r\n } else {\r\n out[p++] = (c >> 12) | 224;\r\n out[p++] = ((c >> 6) & 63) | 128;\r\n out[p++] = (c & 63) | 128;\r\n }\r\n }\r\n return new Uint8Array(out);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _utf8TextEncoder(str) {\r\n if (typeof TextEncoder === 'undefined') throw new Error('TextEncoder not supported');\r\n if (BufferUtils._UTF8_ENCODER === null) throw new Error('TextEncoder does not support utf8');\r\n if (BufferUtils._UTF8_ENCODER === undefined) {\r\n try {\r\n BufferUtils._UTF8_ENCODER = new TextEncoder();\r\n } catch (e) {\r\n BufferUtils._UTF8_ENCODER = null;\r\n throw new Error('TextEncoder does not support utf8');\r\n }\r\n }\r\n return BufferUtils._UTF8_ENCODER.encode(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n */\r\n static fromUtf8(str) {\r\n if (PlatformUtils.isNodeJs()) {\r\n return Buffer.from(str);\r\n } else if (typeof TextEncoder !== 'undefined' && BufferUtils._UTF8_ENCODER !== null) {\r\n try {\r\n return BufferUtils._utf8TextEncoder(str);\r\n } catch (e) {\r\n // Disabled itself\r\n }\r\n }\r\n return BufferUtils._strToUint8Array(str);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array|string} o\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromAny(o, length) {\r\n if (o === '') return SerialBuffer.EMPTY;\r\n if (!o) throw new Error('Invalid buffer format');\r\n if (o instanceof Uint8Array) return new SerialBuffer(o);\r\n try {\r\n return BufferUtils.fromHex(o, length);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n try {\r\n return BufferUtils.fromBase64(o, length);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n throw new Error('Invalid buffer format');\r\n }\r\n\r\n\r\n /**\r\n * @template T\r\n * @param {T} a\r\n * @param {*} b\r\n * @return {T}\r\n */\r\n static concatTypedArrays(a, b) {\r\n const c = new (a.constructor)(a.length + b.length);\r\n c.set(a, 0);\r\n c.set(b, a.length);\r\n return c;\r\n }\r\n\r\n /**\r\n * @param {TypedArray} a\r\n * @param {TypedArray} b\r\n * @return {boolean}\r\n */\r\n static equals(a, b) {\r\n const viewA = BufferUtils._toUint8View(a);\r\n const viewB = BufferUtils._toUint8View(b);\r\n if (viewA.length !== viewB.length) return false;\r\n for (let i = 0; i < viewA.length; i++) {\r\n if (viewA[i] !== viewB[i]) return false;\r\n }\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {TypedArray} a\r\n * @param {TypedArray} b\r\n * @return {number} -1 if a is smaller than b, 1 if a is larger than b, 0 if a equals b.\r\n */\r\n static compare(a, b) {\r\n if (a.length < b.length) return -1;\r\n if (a.length > b.length) return 1;\r\n for (let i = 0; i < a.length; i++) {\r\n if (a[i] < b[i]) return -1;\r\n if (a[i] > b[i]) return 1;\r\n }\r\n return 0;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} a\r\n * @param {Uint8Array} b\r\n * @return {Uint8Array}\r\n */\r\n static xor(a, b) {\r\n const res = new Uint8Array(a.byteLength);\r\n for (let i = 0; i < a.byteLength; ++i) {\r\n res[i] = a[i] ^ b[i];\r\n }\r\n return res;\r\n }\r\n\r\n /**\r\n * @param {TypedArray|ArrayBuffer} arrayLike\r\n * @return {Uint8Array}\r\n * @private\r\n */\r\n static _toUint8View(arrayLike) {\r\n if (arrayLike instanceof Uint8Array) {\r\n return arrayLike;\r\n } else if (arrayLike instanceof ArrayBuffer) {\r\n return new Uint8Array(arrayLike);\r\n } else if (arrayLike.buffer instanceof ArrayBuffer) {\r\n return new Uint8Array(arrayLike.buffer);\r\n } else {\r\n throw new Error('TypedArray or ArrayBuffer required');\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase58(buf, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let encode = [];\r\n let strOutput = '';\r\n let i = 0, j;\r\n\r\n // case of leading zero.\r\n for (; i < buf.length; i++) {\r\n if (buf[i]) {\r\n break;\r\n } else {\r\n strOutput += alphabet[0];\r\n }\r\n }\r\n\r\n for (; i < buf.length; i++) {\r\n let carry = buf[i];\r\n j = 0;\r\n while (j in encode || carry) {\r\n let n = encode[j] ? (encode[j] << 8) + carry : carry;\r\n carry = n / 58 | 0;\r\n encode[j] = n % 58;\r\n j++;\r\n }\r\n }\r\n\r\n while (j--) {\r\n strOutput += alphabet[encode[j]];\r\n }\r\n\r\n return strOutput;\r\n }\r\n\r\n /**\r\n * @param {string} base58\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase58(base58, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let bOutput = [];\r\n let decode = [];\r\n let i = 0, j;\r\n\r\n for (; i < base58.length; i++) {\r\n if (alphabet.indexOf(base58[i])) {\r\n break;\r\n } else {\r\n bOutput.push(0);\r\n }\r\n }\r\n\r\n for (; i < base58.length; i++) {\r\n let carry = alphabet.indexOf(base58[i]);\r\n if (carry < 0) return '';\r\n j = 0;\r\n while (j in decode || carry) {\r\n let n = decode[j] ? decode[j] * 58 + carry: carry;\r\n carry = n >> 8;\r\n decode[j] = n % 256;\r\n j++;\r\n }\r\n }\r\n\r\n while (j--) {\r\n bOutput.push(decode[j]);\r\n }\r\n\r\n return new Uint8Array(bOutput);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {number} [prefix] 0x80 for private key, 0x00 for address\r\n * @param {number} [suffix] 0x01 for private key\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase58Check(buf, prefix = 0x80, suffix, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let input;\r\n if (suffix) input = new SerialBuffer([prefix & 0xff, ...buf, suffix & 0xff])\r\n else input = new SerialBuffer([prefix & 0xff, ...buf]);\r\n const checksum = Hash.computeSha256(Hash.computeSha256(input)).subarray(0, 4);\r\n const buffer = new SerialBuffer([...input, ...checksum]);\r\n return BufferUtils.toBase58(buffer, alphabet);\r\n }\r\n\r\n /**\r\n * @param {string} base58\r\n * @param {string} [hasSuffix] encoded with suffix\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase58Check(base58, hasSuffix = false, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n const output = BufferUtils.fromBase58(base58, alphabet);\r\n // skip the first byte of prefix and the last bytes of suffix and checksum\r\n const end = hasSuffix ? -5 : -4\r\n return new Uint8Array(output.slice(1, end));\r\n }\r\n}\r\nBufferUtils.BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\r\nBufferUtils.BASE32_ALPHABET = {\r\n RFC4648: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',\r\n RFC4648_HEX: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',\r\n KRYPTON: '0123456789ABCDEFGHJKLMNPQRSTUVXY'\r\n};\r\nBufferUtils.HEX_ALPHABET = '0123456789abcdef';\r\nBufferUtils._BASE64_LOOKUP = [];\r\nfor (let i = 0, len = BufferUtils.BASE64_ALPHABET.length; i < len; ++i) {\r\n BufferUtils._BASE64_LOOKUP[i] = BufferUtils.BASE64_ALPHABET[i];\r\n}\r\nBufferUtils.BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\r\n\r\nClass.register(BufferUtils);\r\n","class SerialBuffer extends Uint8Array {\r\n /**\r\n * @param {*} bufferOrArrayOrLength\r\n */\r\n constructor(bufferOrArrayOrLength) {\r\n super(bufferOrArrayOrLength);\r\n this._view = new DataView(this.buffer);\r\n this._readPos = 0;\r\n this._writePos = 0;\r\n }\r\n\r\n /**\r\n * @param {number} [start]\r\n * @param {number} [end]\r\n * @return {Uint8Array}\r\n */\r\n subarray(start, end) {\r\n return ArrayUtils.subarray(this, start, end);\r\n }\r\n\r\n /** @type {number} */\r\n get readPos() {\r\n return this._readPos;\r\n }\r\n\r\n /** @type {number} */\r\n set readPos(value) {\r\n if (value < 0 || value > this.byteLength) throw `Invalid readPos ${value}`;\r\n this._readPos = value;\r\n }\r\n\r\n /** @type {number} */\r\n get writePos() {\r\n return this._writePos;\r\n }\r\n\r\n /** @type {number} */\r\n set writePos(value) {\r\n if (value < 0 || value > this.byteLength) throw `Invalid writePos ${value}`;\r\n this._writePos = value;\r\n }\r\n\r\n /**\r\n * Resets the read and write position of the buffer to zero.\r\n * @returns {void}\r\n */\r\n reset() {\r\n this._readPos = 0;\r\n this._writePos = 0;\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {Uint8Array}\r\n */\r\n read(length) {\r\n const value = this.subarray(this._readPos, this._readPos + length);\r\n this._readPos += length;\r\n return new Uint8Array(value);\r\n }\r\n\r\n /**\r\n * @param {*} array\r\n */\r\n write(array) {\r\n this.set(array, this._writePos);\r\n this._writePos += array.byteLength;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint8() {\r\n return this._view.getUint8(this._readPos++);\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint8(value) {\r\n this._view.setUint8(this._writePos++, value);\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint16() {\r\n const value = this._view.getUint16(this._readPos);\r\n this._readPos += 2;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint16(value) {\r\n this._view.setUint16(this._writePos, value);\r\n this._writePos += 2;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint32() {\r\n const value = this._view.getUint32(this._readPos);\r\n this._readPos += 4;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint32(value) {\r\n this._view.setUint32(this._writePos, value);\r\n this._writePos += 4;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint64() {\r\n const value = this._view.getUint32(this._readPos) * Math.pow(2, 32) + this._view.getUint32(this._readPos + 4);\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n this._readPos += 8;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint64(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n this._view.setUint32(this._writePos, Math.floor(value / Math.pow(2, 32)));\r\n this._view.setUint32(this._writePos + 4, value);\r\n this._writePos += 8;\r\n }\r\n\r\n /**\r\n * @return {BigNumber}\r\n */\r\n readUint128() {\r\n const op96 = new BigNumber('1000000000000000000000000', 16);\r\n const op64 = new BigNumber('10000000000000000', 16);\r\n const op32 = new BigNumber('100000000', 16);\r\n const part1 = this._view.getUint32(this._readPos);\r\n const part2 = this._view.getUint32(this._readPos + 4);\r\n const part3 = this._view.getUint32(this._readPos + 8);\r\n const part4 = this._view.getUint32(this._readPos + 12);\r\n const value = op96.times(part1).plus(op64.times(part2)).plus(op32.times(part3)).plus(part4);\r\n if (!NumberUtils.isUint128(value)) throw new Error('Malformed value');\r\n this._readPos += 16;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {BigNumber} value\r\n */\r\n writeUint128(value) {\r\n if (!NumberUtils.isUint128(value)) throw new Error('Malformed value');\r\n const op96 = new BigNumber('1000000000000000000000000', 16);\r\n const op64 = new BigNumber('10000000000000000', 16);\r\n const op32 = new BigNumber('100000000', 16);\r\n const part1 = value.idiv(op96);\r\n const part2 = value.mod(op96).idiv(op64);\r\n const part3 = value.mod(op64).idiv(op32);\r\n const part4 = value.mod(op32);\r\n this._view.setUint32(this._writePos, part1.toNumber());\r\n this._view.setUint32(this._writePos + 4, part2.toNumber());\r\n this._view.setUint32(this._writePos + 8, part3.toNumber());\r\n this._view.setUint32(this._writePos + 12, part4.toNumber());\r\n this._writePos += 16;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readVarUint() {\r\n const value = this.readUint8();\r\n if (value < 0xFD) {\r\n return value;\r\n } else if (value === 0xFD) {\r\n return this.readUint16();\r\n } else if (value === 0xFE) {\r\n return this.readUint32();\r\n } else /*if (value === 0xFF)*/ {\r\n return this.readUint64();\r\n }\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeVarUint(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n if (value < 0xFD) {\r\n this.writeUint8(value);\r\n } else if (value <= 0xFFFF) {\r\n this.writeUint8(0xFD);\r\n this.writeUint16(value);\r\n } else if (value <= 0xFFFFFFFF) {\r\n this.writeUint8(0xFE);\r\n this.writeUint32(value);\r\n } else {\r\n this.writeUint8(0xFF);\r\n this.writeUint64(value);\r\n }\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n * @returns {number}\r\n */\r\n static varUintSize(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n if (value < 0xFD) {\r\n return 1;\r\n } else if (value <= 0xFFFF) {\r\n return 3;\r\n } else if (value <= 0xFFFFFFFF) {\r\n return 5;\r\n } else {\r\n return 9;\r\n }\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readFloat64() {\r\n const value = this._view.getFloat64(this._readPos);\r\n this._readPos += 8;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeFloat64(value) {\r\n this._view.setFloat64(this._writePos, value);\r\n this._writePos += 8;\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {string}\r\n */\r\n readString(length) {\r\n const bytes = this.read(length);\r\n return BufferUtils.toAscii(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @param {number} length\r\n */\r\n writeString(value, length) {\r\n if (StringUtils.isMultibyte(value) || value.length !== length) throw new Error('Malformed value/length');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.write(bytes);\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {string}\r\n */\r\n readPaddedString(length) {\r\n const bytes = this.read(length);\r\n let i = 0;\r\n while (i < length && bytes[i] !== 0x0) i++;\r\n const view = new Uint8Array(bytes.buffer, bytes.byteOffset, i);\r\n return BufferUtils.toAscii(view);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @param {number} length\r\n */\r\n writePaddedString(value, length) {\r\n if (StringUtils.isMultibyte(value) || value.length > length) throw new Error('Malformed value/length');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.write(bytes);\r\n const padding = length - bytes.byteLength;\r\n this.write(new Uint8Array(padding));\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n readVarLengthString() {\r\n const length = this.readUint8();\r\n if (this._readPos + length > this.length) throw new Error('Malformed length');\r\n const bytes = this.read(length);\r\n return BufferUtils.toAscii(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n */\r\n writeVarLengthString(value) {\r\n if (StringUtils.isMultibyte(value) || !NumberUtils.isUint8(value.length)) throw new Error('Malformed value');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.writeUint8(bytes.byteLength);\r\n this.write(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @returns {number}\r\n */\r\n static varLengthStringSize(value) {\r\n if (StringUtils.isMultibyte(value) || !NumberUtils.isUint8(value.length)) throw new Error('Malformed value');\r\n return /*length*/ 1 + value.length;\r\n }\r\n\r\n /**\r\n * @param {[SerialBuffer]} sources\r\n * @returns {SerialBuffer}\r\n */\r\n static concat(sources) {\r\n const length = sources.reduce((acc, arr) => acc + arr.length, 0);\r\n const result = new SerialBuffer(length);\r\n if (!sources.length) return result;\r\n \r\n let offset = 0;\r\n for(let arr of sources) {\r\n result.set(arr, offset);\r\n offset += arr.length;\r\n }\r\n\r\n return result;\r\n }\r\n}\r\nSerialBuffer.EMPTY = new SerialBuffer(0);\r\nClass.register(SerialBuffer);\r\n","class CRC8 {\r\n // Adapted from https://github.com/mode80/crc8js\r\n static _createTable() {\r\n // Create a lookup table byte array\r\n const table = []; // 256 max len byte array\r\n\r\n for (let i = 0; i < 256; ++i) {\r\n let curr = i;\r\n for (let j = 0; j < 8; ++j) {\r\n if ((curr & 0x80) !== 0) {\r\n curr = ((curr << 1) ^ 0x97) % 256; // Polynomial C2 by Baicheva98\r\n } else {\r\n curr = (curr << 1) % 256;\r\n }\r\n }\r\n table[i] = curr;\r\n }\r\n return table;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @return {number}\r\n */\r\n static compute(buf) {\r\n if (!CRC8._table) CRC8._table = CRC8._createTable();\r\n // Calculate the 8-bit checksum given an array of byte-sized numbers\r\n let c = 0;\r\n for (let i = 0; i < buf.length; i++) {\r\n c = CRC8._table[(c ^ buf[i]) % 256];\r\n }\r\n return c;\r\n }\r\n}\r\nCRC8._table = null;\r\nClass.register(CRC8);\r\n",";(function (globalObject) {\r\n 'use strict';\r\n\r\n /*\r\n * bignumber.js v7.0.1\r\n * A JavaScript library for arbitrary-precision arithmetic.\r\n * https://github.com/MikeMcl/bignumber.js\r\n * Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>\r\n * MIT Licensed.\r\n *\r\n * BigNumber.prototype methods | BigNumber methods\r\n * |\r\n * absoluteValue abs | clone\r\n * comparedTo | config set\r\n * decimalPlaces dp | DECIMAL_PLACES\r\n * dividedBy div | ROUNDING_MODE\r\n * dividedToIntegerBy idiv | EXPONENTIAL_AT\r\n * exponentiatedBy pow | RANGE\r\n * integerValue | CRYPTO\r\n * isEqualTo eq | MODULO_MODE\r\n * isFinite | POW_PRECISION\r\n * isGreaterThan gt | FORMAT\r\n * isGreaterThanOrEqualTo gte | ALPHABET\r\n * isInteger | isBigNumber\r\n * isLessThan lt | maximum max\r\n * isLessThanOrEqualTo lte | minimum min\r\n * isNaN | random\r\n * isNegative |\r\n * isPositive |\r\n * isZero |\r\n * minus |\r\n * modulo mod |\r\n * multipliedBy times |\r\n * negated |\r\n * plus |\r\n * precision sd |\r\n * shiftedBy |\r\n * squareRoot sqrt |\r\n * toExponential |\r\n * toFixed |\r\n * toFormat |\r\n * toFraction |\r\n * toJSON |\r\n * toNumber |\r\n * toPrecision |\r\n * toString |\r\n * valueOf |\r\n *\r\n */\r\n\r\n\r\n var BigNumber,\r\n isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n\r\n mathceil = Math.ceil,\r\n mathfloor = Math.floor,\r\n\r\n bignumberError = '[BigNumber Error] ',\r\n tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n BASE = 1e14,\r\n LOG_BASE = 14,\r\n MAX_SAFE_INTEGER = 0x1fffffffffffff, // 2^53 - 1\r\n // MAX_INT32 = 0x7fffffff, // 2^31 - 1\r\n POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n SQRT_BASE = 1e7,\r\n\r\n // EDITABLE\r\n // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n MAX = 1E9; // 0 to MAX_INT32\r\n\r\n\r\n /*\r\n * Create and return a BigNumber constructor.\r\n */\r\n function clone(configObject) {\r\n var div, convertBase, parseNumeric,\r\n P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n ONE = new BigNumber(1),\r\n\r\n\r\n //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n // The default values below must be integers within the inclusive ranges stated.\r\n // The values can also be changed at run-time using BigNumber.set.\r\n\r\n // The maximum number of decimal places for operations involving division.\r\n DECIMAL_PLACES = 20, // 0 to MAX\r\n\r\n // The rounding mode used when rounding to the above decimal places, and when using\r\n // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n // UP 0 Away from zero.\r\n // DOWN 1 Towards zero.\r\n // CEIL 2 Towards +Infinity.\r\n // FLOOR 3 Towards -Infinity.\r\n // HALF_UP 4 Towards nearest neighbour. If equidistant, up.\r\n // HALF_DOWN 5 Towards nearest neighbour. If equidistant, down.\r\n // HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n // HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n ROUNDING_MODE = 4, // 0 to 8\r\n\r\n // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n // The exponent value at and beneath which toString returns exponential notation.\r\n // Number type: -7\r\n TO_EXP_NEG = -7, // 0 to -MAX\r\n\r\n // The exponent value at and above which toString returns exponential notation.\r\n // Number type: 21\r\n TO_EXP_POS = 21, // 0 to MAX\r\n\r\n // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n // The minimum exponent value, beneath which underflow to zero occurs.\r\n // Number type: -324 (5e-324)\r\n MIN_EXP = -1e7, // -1 to -MAX\r\n\r\n // The maximum exponent value, above which overflow to Infinity occurs.\r\n // Number type: 308 (1.7976931348623157e+308)\r\n // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n MAX_EXP = 1e7, // 1 to MAX\r\n\r\n // Whether to use cryptographically-secure random number generation, if available.\r\n CRYPTO = false, // true or false\r\n\r\n // The modulo mode used when calculating the modulus: a mod n.\r\n // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n // The remainder (r) is calculated as: r = a - n * q.\r\n //\r\n // UP 0 The remainder is positive if the dividend is negative, else is negative.\r\n // DOWN 1 The remainder has the same sign as the dividend.\r\n // This modulo mode is commonly known as 'truncated division' and is\r\n // equivalent to (a % n) in JavaScript.\r\n // FLOOR 3 The remainder has the same sign as the divisor (Python %).\r\n // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n // EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n // The remainder is always positive.\r\n //\r\n // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n // modes are commonly used for the modulus operation.\r\n // Although the other rounding modes can also be used, they may not give useful results.\r\n MODULO_MODE = 1, // 0 to 9\r\n\r\n // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n POW_PRECISION = 0, // 0 to MAX\r\n\r\n // The format specification used by the BigNumber.prototype.toFormat method.\r\n FORMAT = {\r\n decimalSeparator: '.',\r\n groupSeparator: ',',\r\n groupSize: 3,\r\n secondaryGroupSize: 0,\r\n fractionGroupSeparator: '\\xA0', // non-breaking space\r\n fractionGroupSize: 0\r\n },\r\n\r\n // The alphabet used for base conversion.\r\n // It must be at least 2 characters long, with no '.' or repeated character.\r\n // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';\r\n\r\n\r\n //------------------------------------------------------------------------------------------\r\n\r\n\r\n // CONSTRUCTOR\r\n\r\n\r\n /*\r\n * The BigNumber constructor and exported function.\r\n * Create and return a new instance of a BigNumber object.\r\n *\r\n * n {number|string|BigNumber} A numeric value.\r\n * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.\r\n */\r\n function BigNumber(n, b) {\r\n var alphabet, c, e, i, isNum, len, str,\r\n x = this;\r\n\r\n // Enable constructor usage without new.\r\n if (!(x instanceof BigNumber)) {\r\n\r\n // Don't throw on constructor call without new (#81).\r\n // '[BigNumber Error] Constructor call without new: {n}'\r\n //throw Error(bignumberError + ' Constructor call without new: ' + n);\r\n return new BigNumber(n, b);\r\n }\r\n\r\n if (b == null) {\r\n\r\n // Duplicate.\r\n if (n instanceof BigNumber) {\r\n x.s = n.s;\r\n x.e = n.e;\r\n x.c = (n = n.c) ? n.slice() : n;\r\n return;\r\n }\r\n\r\n isNum = typeof n == 'number';\r\n\r\n if (isNum && n * 0 == 0) {\r\n\r\n // Use `1 / n` to handle minus zero also.\r\n x.s = 1 / n < 0 ? (n = -n, -1) : 1;\r\n\r\n // Faster path for integers.\r\n if (n === ~~n) {\r\n for (e = 0, i = n; i >= 10; i /= 10, e++);\r\n x.e = e;\r\n x.c = [n];\r\n return;\r\n }\r\n\r\n str = n + '';\r\n } else {\r\n if (!isNumeric.test(str = n + '')) return parseNumeric(x, str, isNum);\r\n x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n }\r\n\r\n } else {\r\n\r\n // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n intCheck(b, 2, ALPHABET.length, 'Base');\r\n str = n + '';\r\n\r\n // Allow exponential notation to be used with base 10 argument, while\r\n // also rounding to DECIMAL_PLACES as with other bases.\r\n if (b == 10) {\r\n x = new BigNumber(n instanceof BigNumber ? n : str);\r\n return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n }\r\n\r\n isNum = typeof n == 'number';\r\n\r\n if (isNum) {\r\n\r\n // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n if (n * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n throw Error\r\n (tooManyDigits + n);\r\n }\r\n\r\n // Prevent later check for length on converted number.\r\n isNum = false;\r\n } else {\r\n x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n\r\n // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n if (b > 10 && b < 37) str = str.toLowerCase();\r\n }\r\n\r\n alphabet = ALPHABET.slice(0, b);\r\n e = i = 0;\r\n\r\n // Check that str is a valid base b number.\r\n // Don't use RegExp so alphabet can contain special characters.\r\n for (len = str.length; i < len; i++) {\r\n if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n if (c == '.') {\r\n\r\n // If '.' is not the first character and it has not be found before.\r\n if (i > e) {\r\n e = len;\r\n continue;\r\n }\r\n }\r\n\r\n return parseNumeric(x, n + '', isNum, b);\r\n }\r\n }\r\n\r\n str = convertBase(str, b, 10, x.s);\r\n }\r\n\r\n // Decimal point?\r\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n // Exponential form?\r\n if ((i = str.search(/e/i)) > 0) {\r\n\r\n // Determine exponent.\r\n if (e < 0) e = i;\r\n e += +str.slice(i + 1);\r\n str = str.substring(0, i);\r\n } else if (e < 0) {\r\n\r\n // Integer.\r\n e = str.length;\r\n }\r\n\r\n // Determine leading zeros.\r\n for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n // Determine trailing zeros.\r\n for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n str = str.slice(i, ++len);\r\n\r\n if (str) {\r\n len -= i;\r\n\r\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n if (isNum && BigNumber.DEBUG &&\r\n len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {\r\n throw Error\r\n (tooManyDigits + (x.s * n));\r\n }\r\n\r\n e = e - i - 1;\r\n\r\n // Overflow?\r\n if (e > MAX_EXP) {\r\n\r\n // Infinity.\r\n x.c = x.e = null;\r\n\r\n // Underflow?\r\n } else if (e < MIN_EXP) {\r\n\r\n // Zero.\r\n x.c = [x.e = 0];\r\n } else {\r\n x.e = e;\r\n x.c = [];\r\n\r\n // Transform base\r\n\r\n // e is the base 10 exponent.\r\n // i is where to slice str to get the first element of the coefficient array.\r\n i = (e + 1) % LOG_BASE;\r\n if (e < 0) i += LOG_BASE;\r\n\r\n if (i < len) {\r\n if (i) x.c.push(+str.slice(0, i));\r\n\r\n for (len -= LOG_BASE; i < len;) {\r\n x.c.push(+str.slice(i, i += LOG_BASE));\r\n }\r\n\r\n str = str.slice(i);\r\n i = LOG_BASE - str.length;\r\n } else {\r\n i -= len;\r\n }\r\n\r\n for (; i--; str += '0');\r\n x.c.push(+str);\r\n }\r\n } else {\r\n\r\n // Zero.\r\n x.c = [x.e = 0];\r\n }\r\n }\r\n\r\n\r\n // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n BigNumber.clone = clone;\r\n\r\n BigNumber.ROUND_UP = 0;\r\n BigNumber.ROUND_DOWN = 1;\r\n BigNumber.ROUND_CEIL = 2;\r\n BigNumber.ROUND_FLOOR = 3;\r\n BigNumber.ROUND_HALF_UP = 4;\r\n BigNumber.ROUND_HALF_DOWN = 5;\r\n BigNumber.ROUND_HALF_EVEN = 6;\r\n BigNumber.ROUND_HALF_CEIL = 7;\r\n BigNumber.ROUND_HALF_FLOOR = 8;\r\n BigNumber.EUCLID = 9;\r\n\r\n\r\n /*\r\n * Configure infrequently-changing library-wide settings.\r\n *\r\n * Accept an object with the following optional properties (if the value of a property is\r\n * a number, it must be an integer within the inclusive range stated):\r\n *\r\n * DECIMAL_PLACES {number} 0 to MAX\r\n * ROUNDING_MODE {number} 0 to 8\r\n * EXPONENTIAL_AT {number|number[]} -MAX to MAX or [-MAX to 0, 0 to MAX]\r\n * RANGE {number|number[]} -MAX to MAX (not zero) or [-MAX to -1, 1 to MAX]\r\n * CRYPTO {boolean} true or false\r\n * MODULO_MODE {number} 0 to 9\r\n * POW_PRECISION {number} 0 to MAX\r\n * ALPHABET {string} A string of two or more unique characters, and not\r\n * containing '.'. The empty string, null or undefined\r\n * resets the alphabet to its default value.\r\n * FORMAT {object} An object with some of the following properties:\r\n * decimalSeparator {string}\r\n * groupSeparator {string}\r\n * groupSize {number}\r\n * secondaryGroupSize {number}\r\n * fractionGroupSeparator {string}\r\n * fractionGroupSize {number}\r\n *\r\n * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n *\r\n * E.g.\r\n * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n *\r\n * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n *\r\n * Return an object with the properties current values.\r\n */\r\n BigNumber.config = BigNumber.set = function (obj) {\r\n var p, v;\r\n\r\n if (obj != null) {\r\n\r\n if (typeof obj == 'object') {\r\n\r\n // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n v = obj[p];\r\n intCheck(v, 0, MAX, p);\r\n DECIMAL_PLACES = v;\r\n }\r\n\r\n // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n v = obj[p];\r\n intCheck(v, 0, 8, p);\r\n ROUNDING_MODE = v;\r\n }\r\n\r\n // EXPONENTIAL_AT {number|number[]}\r\n // Integer, -MAX to MAX inclusive or\r\n // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n v = obj[p];\r\n if (isArray(v)) {\r\n intCheck(v[0], -MAX, 0, p);\r\n intCheck(v[1], 0, MAX, p);\r\n TO_EXP_NEG = v[0];\r\n TO_EXP_POS = v[1];\r\n } else {\r\n intCheck(v, -MAX, MAX, p);\r\n TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n }\r\n }\r\n\r\n // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n if (obj.hasOwnProperty(p = 'RANGE')) {\r\n v = obj[p];\r\n if (isArray(v)) {\r\n intCheck(v[0], -MAX, -1, p);\r\n intCheck(v[1], 1, MAX, p);\r\n MIN_EXP = v[0];\r\n MAX_EXP = v[1];\r\n } else {\r\n intCheck(v, -MAX, MAX, p);\r\n if (v) {\r\n MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' cannot be zero: ' + v);\r\n }\r\n }\r\n }\r\n\r\n // CRYPTO {boolean} true or false.\r\n // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n // '[BigNumber Error] crypto unavailable'\r\n if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n v = obj[p];\r\n if (v === !!v) {\r\n if (v) {\r\n if (typeof crypto != 'undefined' && crypto &&\r\n (crypto.getRandomValues || crypto.randomBytes)) {\r\n CRYPTO = v;\r\n } else {\r\n CRYPTO = !v;\r\n throw Error\r\n (bignumberError + 'crypto unavailable');\r\n }\r\n } else {\r\n CRYPTO = v;\r\n }\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' not true or false: ' + v);\r\n }\r\n }\r\n\r\n // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n v = obj[p];\r\n intCheck(v, 0, 9, p);\r\n MODULO_MODE = v;\r\n }\r\n\r\n // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n v = obj[p];\r\n intCheck(v, 0, MAX, p);\r\n POW_PRECISION = v;\r\n }\r\n\r\n // FORMAT {object}\r\n // '[BigNumber Error] FORMAT not an object: {v}'\r\n if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n v = obj[p];\r\n if (typeof v == 'object') FORMAT = v;\r\n else throw Error\r\n (bignumberError + p + ' not an object: ' + v);\r\n }\r\n\r\n // ALPHABET {string}\r\n // '[BigNumber Error] ALPHABET invalid: {v}'\r\n if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n v = obj[p];\r\n\r\n // Disallow if only one character, or contains '.' or a repeated character.\r\n if (typeof v == 'string' && !/^.$|\\.|(.).*\\1/.test(v)) {\r\n ALPHABET = v;\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' invalid: ' + v);\r\n }\r\n }\r\n\r\n } else {\r\n\r\n // '[BigNumber Error] Object expected: {v}'\r\n throw Error\r\n (bignumberError + 'Object expected: ' + obj);\r\n }\r\n }\r\n\r\n return {\r\n DECIMAL_PLACES: DECIMAL_PLACES,\r\n ROUNDING_MODE: ROUNDING_MODE,\r\n EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n RANGE: [MIN_EXP, MAX_EXP],\r\n CRYPTO: CRYPTO,\r\n MODULO_MODE: MODULO_MODE,\r\n POW_PRECISION: POW_PRECISION,\r\n FORMAT: FORMAT,\r\n ALPHABET: ALPHABET\r\n };\r\n };\r\n\r\n\r\n /*\r\n * Return true if v is a BigNumber instance, otherwise return false.\r\n *\r\n * v {any}\r\n */\r\n BigNumber.isBigNumber = function (v) {\r\n return v instanceof BigNumber || v && v._isBigNumber === true || false;\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\r\n BigNumber.maximum = BigNumber.max = function () {\r\n return maxOrMin(arguments, P.lt);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\r\n BigNumber.minimum = BigNumber.min = function () {\r\n return maxOrMin(arguments, P.gt);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n * zeros are produced).\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n * '[BigNumber Error] crypto unavailable'\r\n */\r\n BigNumber.random = (function () {\r\n var pow2_53 = 0x20000000000000;\r\n\r\n // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n // Check if Math.random() produces more than 32 bits of randomness.\r\n // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n ? function () { return mathfloor(Math.random() * pow2_53); }\r\n : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n (Math.random() * 0x800000 | 0); };\r\n\r\n return function (dp) {\r\n var a, b, e, k, v,\r\n i = 0,\r\n c = [],\r\n rand = new BigNumber(ONE);\r\n\r\n if (dp == null) dp = DECIMAL_PLACES;\r\n else intCheck(dp, 0, MAX);\r\n\r\n k = mathceil(dp / LOG_BASE);\r\n\r\n if (CRYPTO) {\r\n\r\n // Browsers supporting crypto.getRandomValues.\r\n if (crypto.getRandomValues) {\r\n\r\n a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n for (; i < k;) {\r\n\r\n // 53 bits:\r\n // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n // 11111 11111111 11111111\r\n // 0x20000 is 2^21.\r\n v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n // Rejection sampling:\r\n // 0 <= v < 9007199254740992\r\n // Probability that v >= 9e15, is\r\n // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n if (v >= 9e15) {\r\n b = crypto.getRandomValues(new Uint32Array(2));\r\n a[i] = b[0];\r\n a[i + 1] = b[1];\r\n } else {\r\n\r\n // 0 <= v <= 8999999999999999\r\n // 0 <= (v % 1e14) <= 99999999999999\r\n c.push(v % 1e14);\r\n i += 2;\r\n }\r\n }\r\n i = k / 2;\r\n\r\n // Node.js supporting crypto.randomBytes.\r\n } else if (crypto.randomBytes) {\r\n\r\n // buffer\r\n a = crypto.randomBytes(k *= 7);\r\n\r\n for (; i < k;) {\r\n\r\n // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n // 0 <= v < 9007199254740992\r\n v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n if (v >= 9e15) {\r\n crypto.randomBytes(7).copy(a, i);\r\n } else {\r\n\r\n // 0 <= (v % 1e14) <= 99999999999999\r\n c.push(v % 1e14);\r\n i += 7;\r\n }\r\n }\r\n i = k / 7;\r\n } else {\r\n CRYPTO = false;\r\n throw Error\r\n (bignumberError + 'crypto unavailable');\r\n }\r\n }\r\n\r\n // Use Math.random.\r\n if (!CRYPTO) {\r\n\r\n for (; i < k;) {\r\n v = random53bitInt();\r\n if (v < 9e15) c[i++] = v % 1e14;\r\n }\r\n }\r\n\r\n k = c[--i];\r\n dp %= LOG_BASE;\r\n\r\n // Convert trailing digits to zeros according to dp.\r\n if (k && dp) {\r\n v = POWS_TEN[LOG_BASE - dp];\r\n c[i] = mathfloor(k / v) * v;\r\n }\r\n\r\n // Remove trailing elements which are zero.\r\n for (; c[i] === 0; c.pop(), i--);\r\n\r\n // Zero?\r\n if (i < 0) {\r\n c = [e = 0];\r\n } else {\r\n\r\n // Remove leading elements which are zero and adjust exponent accordingly.\r\n for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n // Count the digits of the first element of c to determine leading zeros, and...\r\n for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n // adjust the exponent accordingly.\r\n if (i < LOG_BASE) e -= LOG_BASE - i;\r\n }\r\n\r\n rand.e = e;\r\n rand.c = c;\r\n return rand;\r\n };\r\n })();\r\n\r\n\r\n // PRIVATE FUNCTIONS\r\n\r\n\r\n // Called by BigNumber and BigNumber.prototype.toString.\r\n convertBase = (function () {\r\n var decimal = '0123456789';\r\n\r\n /*\r\n * Convert string of baseIn to an array of numbers of baseOut.\r\n * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n */\r\n function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n var j,\r\n arr = [0],\r\n arrL,\r\n i = 0,\r\n len = str.length;\r\n\r\n for (; i < len;) {\r\n for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n for (j = 0; j < arr.length; j++) {\r\n\r\n if (arr[j] > baseOut - 1) {\r\n if (arr[j + 1] == null) arr[j + 1] = 0;\r\n arr[j + 1] += arr[j] / baseOut | 0;\r\n arr[j] %= baseOut;\r\n }\r\n }\r\n }\r\n\r\n return arr.reverse();\r\n }\r\n\r\n // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n // If the caller is toString, we are converting from base 10 to baseOut.\r\n // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n var alphabet, d, e, k, r, x, xc, y,\r\n i = str.indexOf('.'),\r\n dp = DECIMAL_PLACES,\r\n rm = ROUNDING_MODE;\r\n\r\n // Non-integer.\r\n if (i >= 0) {\r\n k = POW_PRECISION;\r\n\r\n // Unlimited precision.\r\n POW_PRECISION = 0;\r\n str = str.replace('.', '');\r\n y = new BigNumber(baseIn);\r\n x = y.pow(str.length - i);\r\n POW_PRECISION = k;\r\n\r\n // Convert str as if an integer, then restore the fraction part by dividing the\r\n // result by its base raised to a power.\r\n\r\n y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n 10, baseOut, decimal);\r\n y.e = y.c.length;\r\n }\r\n\r\n // Convert the number as integer.\r\n\r\n xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n ? (alphabet = ALPHABET, decimal)\r\n : (alphabet = decimal, ALPHABET));\r\n\r\n // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n e = k = xc.length;\r\n\r\n // Remove trailing zeros.\r\n for (; xc[--k] == 0; xc.pop());\r\n\r\n // Zero?\r\n if (!xc[0]) return alphabet.charAt(0);\r\n\r\n // Does str represent an integer? If so, no need for the division.\r\n if (i < 0) {\r\n --e;\r\n } else {\r\n x.c = xc;\r\n x.e = e;\r\n\r\n // The sign is needed for correct rounding.\r\n x.s = sign;\r\n x = div(x, y, dp, rm, baseOut);\r\n xc = x.c;\r\n r = x.r;\r\n e = x.e;\r\n }\r\n\r\n // xc now represents str converted to baseOut.\r\n\r\n // THe index of the rounding digit.\r\n d = e + dp + 1;\r\n\r\n // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n i = xc[d];\r\n\r\n // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n k = baseOut / 2;\r\n r = r || d < 0 || xc[d + 1] != null;\r\n\r\n r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n // If the index of the rounding digit is not greater than zero, or xc represents\r\n // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n // such as 0.00001.\r\n if (d < 1 || !xc[0]) {\r\n\r\n // 1^-dp or 0\r\n str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0))\r\n : alphabet.charAt(0);\r\n } else {\r\n\r\n // Truncate xc to the required number of decimal places.\r\n xc.length = d;\r\n\r\n // Round up?\r\n if (r) {\r\n\r\n // Rounding up may mean the previous digit has to be rounded up and so on.\r\n for (--baseOut; ++xc[--d] > baseOut;) {\r\n xc[d] = 0;\r\n\r\n if (!d) {\r\n ++e;\r\n xc = [1].concat(xc);\r\n }\r\n }\r\n }\r\n\r\n // Determine trailing zeros.\r\n for (k = xc.length; !xc[--k];);\r\n\r\n // E.g. [4, 11, 15] becomes 4bf.\r\n for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n // Add leading zeros, decimal point and trailing zeros as required.\r\n str = toFixedPoint(str, e, alphabet.charAt(0));\r\n }\r\n\r\n // The caller will add the sign.\r\n return str;\r\n };\r\n })();\r\n\r\n\r\n // Perform division in the specified base. Called by div and convertBase.\r\n div = (function () {\r\n\r\n // Assume non-zero x and k.\r\n function multiply(x, k, base) {\r\n var m, temp, xlo, xhi,\r\n carry = 0,\r\n i = x.length,\r\n klo = k % SQRT_BASE,\r\n khi = k / SQRT_BASE | 0;\r\n\r\n for (x = x.slice(); i--;) {\r\n xlo = x[i] % SQRT_BASE;\r\n xhi = x[i] / SQRT_BASE | 0;\r\n m = khi * xlo + xhi * klo;\r\n temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n x[i] = temp % base;\r\n }\r\n\r\n if (carry) x = [carry].concat(x);\r\n\r\n return x;\r\n }\r\n\r\n function compare(a, b, aL, bL) {\r\n var i, cmp;\r\n\r\n if (aL != bL) {\r\n cmp = aL > bL ? 1 : -1;\r\n } else {\r\n\r\n for (i = cmp = 0; i < aL; i++) {\r\n\r\n if (a[i] != b[i]) {\r\n cmp = a[i] > b[i] ? 1 : -1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n return cmp;\r\n }\r\n\r\n function subtract(a, b, aL, base) {\r\n var i = 0;\r\n\r\n // Subtract b from a.\r\n for (; aL--;) {\r\n a[aL] -= i;\r\n i = a[aL] < b[aL] ? 1 : 0;\r\n a[aL] = i * base + a[aL] - b[aL];\r\n }\r\n\r\n // Remove leading zeros.\r\n for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n }\r\n\r\n // x: dividend, y: divisor.\r\n return function (x, y, dp, rm, base) {\r\n var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n yL, yz,\r\n s = x.s == y.s ? 1 : -1,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n // Either NaN, Infinity or 0?\r\n if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n return new BigNumber(\r\n\r\n // Return NaN if either NaN, or both Infinity or 0.\r\n !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n );\r\n }\r\n\r\n q = new BigNumber(s);\r\n qc = q.c = [];\r\n e = x.e - y.e;\r\n s = dp + e + 1;\r\n\r\n if (!base) {\r\n base = BASE;\r\n e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n s = s / LOG_BASE | 0;\r\n }\r\n\r\n // Result exponent may be one less then the current value of e.\r\n // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n if (s < 0) {\r\n qc.push(1);\r\n more = true;\r\n } else {\r\n xL = xc.length;\r\n yL = yc.length;\r\n i = 0;\r\n s += 2;\r\n\r\n // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n n = mathfloor(base / (yc[0] + 1));\r\n\r\n // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n if (n > 1) {\r\n yc = multiply(yc, n, base);\r\n xc = multiply(xc, n, base);\r\n yL = yc.length;\r\n xL = xc.length;\r\n }\r\n\r\n xi = yL;\r\n rem = xc.slice(0, yL);\r\n remL = rem.length;\r\n\r\n // Add zeros to make remainder as long as divisor.\r\n for (; remL < yL; rem[remL++] = 0);\r\n yz = yc.slice();\r\n yz = [0].concat(yz);\r\n yc0 = yc[0];\r\n if (yc[1] >= base / 2) yc0++;\r\n // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n do {\r\n n = 0;\r\n\r\n // Compare divisor and remainder.\r\n cmp = compare(yc, rem, yL, remL);\r\n\r\n // If divisor < remainder.\r\n if (cmp < 0) {\r\n\r\n // Calculate trial digit, n.\r\n\r\n rem0 = rem[0];\r\n if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n // n is how many times the divisor goes into the current remainder.\r\n n = mathfloor(rem0 / yc0);\r\n\r\n // Algorithm:\r\n // product = divisor multiplied by trial digit (n).\r\n // Compare product and remainder.\r\n // If product is greater than remainder:\r\n // Subtract divisor from product, decrement trial digit.\r\n // Subtract product from remainder.\r\n // If product was less than remainder at the last compare:\r\n // Compare new remainder and divisor.\r\n // If remainder is greater than divisor:\r\n // Subtract divisor from remainder, increment trial digit.\r\n\r\n if (n > 1) {\r\n\r\n // n may be > base only when base is 3.\r\n if (n >= base) n = base - 1;\r\n\r\n // product = divisor * trial digit.\r\n prod = multiply(yc, n, base);\r\n prodL = prod.length;\r\n remL = rem.length;\r\n\r\n // Compare product and remainder.\r\n // If product > remainder then trial digit n too high.\r\n // n is 1 too high about 5% of the time, and is not known to have\r\n // ever been more than 1 too high.\r\n while (compare(prod, rem, prodL, remL) == 1) {\r\n n--;\r\n\r\n // Subtract divisor from product.\r\n subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n prodL = prod.length;\r\n cmp = 1;\r\n }\r\n } else {\r\n\r\n // n is 0 or 1, cmp is -1.\r\n // If n is 0, there is no need to compare yc and rem again below,\r\n // so change cmp to 1 to avoid it.\r\n // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n if (n == 0) {\r\n\r\n // divisor < remainder, so n must be at least 1.\r\n cmp = n = 1;\r\n }\r\n\r\n // product = divisor\r\n prod = yc.slice();\r\n prodL = prod.length;\r\n }\r\n\r\n if (prodL < remL) prod = [0].concat(prod);\r\n\r\n // Subtract product from remainder.\r\n subtract(rem, prod, remL, base);\r\n remL = rem.length;\r\n\r\n // If product was < remainder.\r\n if (cmp == -1) {\r\n\r\n // Compare divisor and new remainder.\r\n // If divisor < new remainder, subtract divisor from remainder.\r\n // Trial digit n too low.\r\n // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n while (compare(yc, rem, yL, remL) < 1) {\r\n n++;\r\n\r\n // Subtract divisor from remainder.\r\n subtract(rem, yL < remL ? yz : yc, remL, base);\r\n remL = rem.length;\r\n }\r\n }\r\n } else if (cmp === 0) {\r\n n++;\r\n rem = [0];\r\n } // else cmp === 1 and n will be 0\r\n\r\n // Add the next digit, n, to the result array.\r\n qc[i++] = n;\r\n\r\n // Update the remainder.\r\n if (rem[0]) {\r\n rem[remL++] = xc[xi] || 0;\r\n } else {\r\n rem = [xc[xi]];\r\n remL = 1;\r\n }\r\n } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n more = rem[0] != null;\r\n\r\n // Leading zero?\r\n if (!qc[0]) qc.splice(0, 1);\r\n }\r\n\r\n if (base == BASE) {\r\n\r\n // To calculate q.e, first get the number of digits of qc[0].\r\n for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n // Caller is convertBase.\r\n } else {\r\n q.e = e;\r\n q.r = +more;\r\n }\r\n\r\n return q;\r\n };\r\n })();\r\n\r\n\r\n /*\r\n * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n * notation rounded to the specified decimal places or significant digits.\r\n *\r\n * n: a BigNumber.\r\n * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n * rm: the rounding mode.\r\n * id: 1 (toExponential) or 2 (toPrecision).\r\n */\r\n function format(n, i, rm, id) {\r\n var c0, e, ne, len, str;\r\n\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n if (!n.c) return n.toString();\r\n\r\n c0 = n.c[0];\r\n ne = n.e;\r\n\r\n if (i == null) {\r\n str = coeffToString(n.c);\r\n str = id == 1 || id == 2 && ne <= TO_EXP_NEG\r\n ? toExponential(str, ne)\r\n : toFixedPoint(str, ne, '0');\r\n } else {\r\n n = round(new BigNumber(n), i, rm);\r\n\r\n // n.e may have changed if the value was rounded up.\r\n e = n.e;\r\n\r\n str = coeffToString(n.c);\r\n len = str.length;\r\n\r\n // toPrecision returns exponential notation if the number of significant digits\r\n // specified is less than the number of digits necessary to represent the integer\r\n // part of the value in fixed-point notation.\r\n\r\n // Exponential notation.\r\n if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n // Append zeros?\r\n for (; len < i; str += '0', len++);\r\n str = toExponential(str, e);\r\n\r\n // Fixed-point notation.\r\n } else {\r\n i -= ne;\r\n str = toFixedPoint(str, e, '0');\r\n\r\n // Append zeros?\r\n if (e + 1 > len) {\r\n if (--i > 0) for (str += '.'; i--; str += '0');\r\n } else {\r\n i += e - len;\r\n if (i > 0) {\r\n if (e + 1 == len) str += '.';\r\n for (; i--; str += '0');\r\n }\r\n }\r\n }\r\n }\r\n\r\n return n.s < 0 && c0 ? '-' + str : str;\r\n }\r\n\r\n\r\n // Handle BigNumber.max and BigNumber.min.\r\n function maxOrMin(args, method) {\r\n var m, n,\r\n i = 0;\r\n\r\n if (isArray(args[0])) args = args[0];\r\n m = new BigNumber(args[0]);\r\n\r\n for (; ++i < args.length;) {\r\n n = new BigNumber(args[i]);\r\n\r\n // If any number is NaN, return NaN.\r\n if (!n.s) {\r\n m = n;\r\n break;\r\n } else if (method.call(m, n)) {\r\n m = n;\r\n }\r\n }\r\n\r\n return m;\r\n }\r\n\r\n\r\n /*\r\n * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n * Called by minus, plus and times.\r\n */\r\n function normalise(n, c, e) {\r\n var i = 1,\r\n j = c.length;\r\n\r\n // Remove trailing zeros.\r\n for (; !c[--j]; c.pop());\r\n\r\n // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n // Overflow?\r\n if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n // Infinity.\r\n n.c = n.e = null;\r\n\r\n // Underflow?\r\n } else if (e < MIN_EXP) {\r\n\r\n // Zero.\r\n n.c = [n.e = 0];\r\n } else {\r\n n.e = e;\r\n n.c = c;\r\n }\r\n\r\n return n;\r\n }\r\n\r\n\r\n // Handle values that fail the validity test in BigNumber.\r\n parseNumeric = (function () {\r\n var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n dotAfter = /^([^.]+)\\.$/,\r\n dotBefore = /^\\.([^.]+)$/,\r\n isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n return function (x, str, isNum, b) {\r\n var base,\r\n s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n // No exception on ±Infinity or NaN.\r\n if (isInfinityOrNaN.test(s)) {\r\n x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n x.c = x.e = null;\r\n } else {\r\n if (!isNum) {\r\n\r\n // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n s = s.replace(basePrefix, function (m, p1, p2) {\r\n base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n return !b || b == base ? p1 : m;\r\n });\r\n\r\n if (b) {\r\n base = b;\r\n\r\n // E.g. '1.' to '1', '.1' to '0.1'\r\n s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n }\r\n\r\n if (str != s) return new BigNumber(s, base);\r\n }\r\n\r\n // '[BigNumber Error] Not a number: {n}'\r\n // '[BigNumber Error] Not a base {b} number: {n}'\r\n if (BigNumber.DEBUG) {\r\n throw Error\r\n (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n }\r\n\r\n // NaN\r\n x.c = x.e = x.s = null;\r\n }\r\n }\r\n })();\r\n\r\n\r\n /*\r\n * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n * If r is truthy, it is known that there are more digits after the rounding digit.\r\n */\r\n function round(x, sd, rm, r) {\r\n var d, i, j, k, n, ni, rd,\r\n xc = x.c,\r\n pows10 = POWS_TEN;\r\n\r\n // if x is not Infinity or NaN...\r\n if (xc) {\r\n\r\n // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n // ni is the index of n within x.c.\r\n // d is the number of digits of n.\r\n // i is the index of rd within n including leading zeros.\r\n // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n out: {\r\n\r\n // Get the number of digits of the first element of xc.\r\n for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n i = sd - d;\r\n\r\n // If the rounding digit is in the first element of xc...\r\n if (i < 0) {\r\n i += LOG_BASE;\r\n j = sd;\r\n n = xc[ni = 0];\r\n\r\n // Get the rounding digit at index j of n.\r\n rd = n / pows10[d - j - 1] % 10 | 0;\r\n } else {\r\n ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n if (ni >= xc.length) {\r\n\r\n if (r) {\r\n\r\n // Needed by sqrt.\r\n for (; xc.length <= ni; xc.push(0));\r\n n = rd = 0;\r\n d = 1;\r\n i %= LOG_BASE;\r\n j = i - LOG_BASE + 1;\r\n } else {\r\n break out;\r\n }\r\n } else {\r\n n = k = xc[ni];\r\n\r\n // Get the number of digits of n.\r\n for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n // Get the index of rd within n.\r\n i %= LOG_BASE;\r\n\r\n // Get the index of rd within n, adjusted for leading zeros.\r\n // The number of leading zeros of n is given by LOG_BASE - d.\r\n j = i - LOG_BASE + d;\r\n\r\n // Get the rounding digit at index j of n.\r\n rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n }\r\n }\r\n\r\n r = r || sd < 0 ||\r\n\r\n // Are there any non-zero digits after the rounding digit?\r\n // The expression n % pows10[d - j - 1] returns all digits of n to the right\r\n // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n r = rm < 4\r\n ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n // Check whether the digit to the left of the rounding digit is odd.\r\n ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n if (sd < 1 || !xc[0]) {\r\n xc.length = 0;\r\n\r\n if (r) {\r\n\r\n // Convert sd to decimal places.\r\n sd -= x.e + 1;\r\n\r\n // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n x.e = -sd || 0;\r\n } else {\r\n\r\n // Zero.\r\n xc[0] = x.e = 0;\r\n }\r\n\r\n return x;\r\n }\r\n\r\n // Remove excess digits.\r\n if (i == 0) {\r\n xc.length = ni;\r\n k = 1;\r\n ni--;\r\n } else {\r\n xc.length = ni + 1;\r\n k = pows10[LOG_BASE - i];\r\n\r\n // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n // j > 0 means i > number of leading zeros of n.\r\n xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n }\r\n\r\n // Round up?\r\n if (r) {\r\n\r\n for (; ;) {\r\n\r\n // If the digit to be rounded up is in the first element of xc...\r\n if (ni == 0) {\r\n\r\n // i will be the length of xc[0] before k is added.\r\n for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n j = xc[0] += k;\r\n for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n // if i != k the length has increased.\r\n if (i != k) {\r\n x.e++;\r\n if (xc[0] == BASE) xc[0] = 1;\r\n }\r\n\r\n break;\r\n } else {\r\n xc[ni] += k;\r\n if (xc[ni] != BASE) break;\r\n xc[ni--] = 0;\r\n k = 1;\r\n }\r\n }\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (i = xc.length; xc[--i] === 0; xc.pop());\r\n }\r\n\r\n // Overflow? Infinity.\r\n if (x.e > MAX_EXP) {\r\n x.c = x.e = null;\r\n\r\n // Underflow? Zero.\r\n } else if (x.e < MIN_EXP) {\r\n x.c = [x.e = 0];\r\n }\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n */\r\n P.absoluteValue = P.abs = function () {\r\n var x = new BigNumber(this);\r\n if (x.s < 0) x.s = 1;\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * 0 if they have the same value,\r\n * or null if the value of either is NaN.\r\n */\r\n P.comparedTo = function (y, b) {\r\n return compare(this, new BigNumber(y, b));\r\n };\r\n\r\n\r\n /*\r\n * If dp is undefined or null or true or false, return the number of decimal places of the\r\n * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n *\r\n * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.decimalPlaces = P.dp = function (dp, rm) {\r\n var c, n, v,\r\n x = this;\r\n\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n return round(new BigNumber(x), dp + x.e + 1, rm);\r\n }\r\n\r\n if (!(c = x.c)) return null;\r\n n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n // Subtract the number of trailing zeros of the last number.\r\n if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n if (n < 0) n = 0;\r\n\r\n return n;\r\n };\r\n\r\n\r\n /*\r\n * n / 0 = I\r\n * n / N = N\r\n * n / I = 0\r\n * 0 / n = 0\r\n * 0 / 0 = N\r\n * 0 / N = N\r\n * 0 / I = 0\r\n * N / n = N\r\n * N / 0 = N\r\n * N / N = N\r\n * N / I = N\r\n * I / n = I\r\n * I / 0 = I\r\n * I / N = N\r\n * I / I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\r\n P.dividedBy = P.div = function (y, b) {\r\n return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n * BigNumber by the value of BigNumber(y, b).\r\n */\r\n P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n return div(this, new BigNumber(y, b), 0, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n *\r\n * If m is present, return the result modulo m.\r\n * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n *\r\n * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n *\r\n * n {number|string|BigNumber} The exponent. An integer.\r\n * [m] {number|string|BigNumber} The modulus.\r\n *\r\n * '[BigNumber Error] Exponent not an integer: {n}'\r\n */\r\n P.exponentiatedBy = P.pow = function (n, m) {\r\n var half, isModExp, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n x = this;\r\n\r\n n = new BigNumber(n);\r\n\r\n // Allow NaN and ±Infinity, but not other non-integers.\r\n if (n.c && !n.isInteger()) {\r\n throw Error\r\n (bignumberError + 'Exponent not an integer: ' + n);\r\n }\r\n\r\n if (m != null) m = new BigNumber(m);\r\n\r\n // Exponent of MAX_SAFE_INTEGER is 15.\r\n nIsBig = n.e > 14;\r\n\r\n // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n // The sign of the result of pow when x is negative depends on the evenness of n.\r\n // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n y = new BigNumber(Math.pow(+x.valueOf(), nIsBig ? 2 - isOdd(n) : +n));\r\n return m ? y.mod(m) : y;\r\n }\r\n\r\n nIsNeg = n.s < 0;\r\n\r\n if (m) {\r\n\r\n // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n if (isModExp) x = x.mod(m);\r\n\r\n // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n // [1, 240000000]\r\n ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n // [80000000000000] [99999750000000]\r\n : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n // If x is negative and n is odd, k = -0, else k = 0.\r\n k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n // If x >= 1, k = ±Infinity.\r\n if (x.e > -1) k = 1 / k;\r\n\r\n // If n is negative return ±0, else return ±Infinity.\r\n return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n } else if (POW_PRECISION) {\r\n\r\n // Truncating each coefficient array to a length of k after each multiplication\r\n // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n // i.e. there will be a minimum of 28 guard digits retained.\r\n k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n }\r\n\r\n if (nIsBig) {\r\n half = new BigNumber(0.5);\r\n nIsOdd = isOdd(n);\r\n } else {\r\n nIsOdd = n % 2;\r\n }\r\n\r\n if (nIsNeg) n.s = 1;\r\n\r\n y = new BigNumber(ONE);\r\n\r\n // Performs 54 loop iterations for n of 9007199254740991.\r\n for (; ;) {\r\n\r\n if (nIsOdd) {\r\n y = y.times(x);\r\n if (!y.c) break;\r\n\r\n if (k) {\r\n if (y.c.length > k) y.c.length = k;\r\n } else if (isModExp) {\r\n y = y.mod(m); //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n }\r\n }\r\n\r\n if (nIsBig) {\r\n n = n.times(half);\r\n round(n, n.e + 1, 1);\r\n if (!n.c[0]) break;\r\n nIsBig = n.e > 14;\r\n nIsOdd = isOdd(n);\r\n } else {\r\n n = mathfloor(n / 2);\r\n if (!n) break;\r\n nIsOdd = n % 2;\r\n }\r\n\r\n x = x.times(x);\r\n\r\n if (k) {\r\n if (x.c && x.c.length > k) x.c.length = k;\r\n } else if (isModExp) {\r\n x = x.mod(m); //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n }\r\n }\r\n\r\n if (isModExp) return y;\r\n if (nIsNeg) y = ONE.div(y);\r\n\r\n return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n */\r\n P.integerValue = function (rm) {\r\n var n = new BigNumber(this);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n return round(n, n.e + 1, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isEqualTo = P.eq = P.equals = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n */\r\n P.isFinite = function () {\r\n return !!this.c;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isGreaterThan = P.gt = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is greater than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\r\n P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n */\r\n P.isInteger = function () {\r\n return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isLessThan = P.lt = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is less than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\r\n P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n */\r\n P.isNaN = function () {\r\n return !this.s;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is negative, otherwise return false.\r\n */\r\n P.isNegative = function () {\r\n return this.s < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is positive, otherwise return false.\r\n */\r\n P.isPositive = function () {\r\n return this.s > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n */\r\n P.isZero = function () {\r\n return !!this.c && this.c[0] == 0;\r\n };\r\n\r\n\r\n /*\r\n * n - 0 = n\r\n * n - N = N\r\n * n - I = -I\r\n * 0 - n = -n\r\n * 0 - 0 = 0\r\n * 0 - N = N\r\n * 0 - I = -I\r\n * N - n = N\r\n * N - 0 = N\r\n * N - N = N\r\n * N - I = N\r\n * I - n = I\r\n * I - 0 = I\r\n * I - N = N\r\n * I - I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n * BigNumber(y, b).\r\n */\r\n P.minus = function (y, b) {\r\n var i, j, t, xLTy,\r\n x = this,\r\n a = x.s;\r\n\r\n y = new BigNumber(y, b);\r\n b = y.s;\r\n\r\n // Either NaN?\r\n if (!a || !b) return new BigNumber(NaN);\r\n\r\n // Signs differ?\r\n if (a != b) {\r\n y.s = -b;\r\n return x.plus(y);\r\n }\r\n\r\n var xe = x.e / LOG_BASE,\r\n ye = y.e / LOG_BASE,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n if (!xe || !ye) {\r\n\r\n // Either Infinity?\r\n if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n // Either zero?\r\n if (!xc[0] || !yc[0]) {\r\n\r\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n ROUNDING_MODE == 3 ? -0 : 0);\r\n }\r\n }\r\n\r\n xe = bitFloor(xe);\r\n ye = bitFloor(ye);\r\n xc = xc.slice();\r\n\r\n // Determine which is the bigger number.\r\n if (a = xe - ye) {\r\n\r\n if (xLTy = a < 0) {\r\n a = -a;\r\n t = xc;\r\n } else {\r\n ye = xe;\r\n t = yc;\r\n }\r\n\r\n t.reverse();\r\n\r\n // Prepend zeros to equalise exponents.\r\n for (b = a; b--; t.push(0));\r\n t.reverse();\r\n } else {\r\n\r\n // Exponents equal. Check digit by digit.\r\n j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n for (a = b = 0; b < j; b++) {\r\n\r\n if (xc[b] != yc[b]) {\r\n xLTy = xc[b] < yc[b];\r\n break;\r\n }\r\n }\r\n }\r\n\r\n // x < y? Point xc to the array of the bigger number.\r\n if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n b = (j = yc.length) - (i = xc.length);\r\n\r\n // Append zeros to xc if shorter.\r\n // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n if (b > 0) for (; b--; xc[i++] = 0);\r\n b = BASE - 1;\r\n\r\n // Subtract yc from xc.\r\n for (; j > a;) {\r\n\r\n if (xc[--j] < yc[j]) {\r\n for (i = j; i && !xc[--i]; xc[i] = b);\r\n --xc[i];\r\n xc[j] += BASE;\r\n }\r\n\r\n xc[j] -= yc[j];\r\n }\r\n\r\n // Remove leading zeros and adjust exponent accordingly.\r\n for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n // Zero?\r\n if (!xc[0]) {\r\n\r\n // Following IEEE 754 (2008) 6.3,\r\n // n - n = +0 but n - n = -0 when rounding towards -Infinity.\r\n y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n y.c = [y.e = 0];\r\n return y;\r\n }\r\n\r\n // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n // for finite x and y.\r\n return normalise(y, xc, ye);\r\n };\r\n\r\n\r\n /*\r\n * n % 0 = N\r\n * n % N = N\r\n * n % I = n\r\n * 0 % n = 0\r\n * -0 % n = -0\r\n * 0 % 0 = N\r\n * 0 % N = N\r\n * 0 % I = 0\r\n * N % n = N\r\n * N % 0 = N\r\n * N % N = N\r\n * N % I = N\r\n * I % n = N\r\n * I % 0 = N\r\n * I % N = N\r\n * I % I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n */\r\n P.modulo = P.mod = function (y, b) {\r\n var q, s,\r\n x = this;\r\n\r\n y = new BigNumber(y, b);\r\n\r\n // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n if (!x.c || !y.s || y.c && !y.c[0]) {\r\n return new BigNumber(NaN);\r\n\r\n // Return x if y is Infinity or x is zero.\r\n } else if (!y.c || x.c && !x.c[0]) {\r\n return new BigNumber(x);\r\n }\r\n\r\n if (MODULO_MODE == 9) {\r\n\r\n // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n // r = x - qy where 0 <= r < abs(y)\r\n s = y.s;\r\n y.s = 1;\r\n q = div(x, y, 0, 3);\r\n y.s = s;\r\n q.s *= s;\r\n } else {\r\n q = div(x, y, 0, MODULO_MODE);\r\n }\r\n\r\n y = x.minus(q.times(y));\r\n\r\n // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n return y;\r\n };\r\n\r\n\r\n /*\r\n * n * 0 = 0\r\n * n * N = N\r\n * n * I = I\r\n * 0 * n = 0\r\n * 0 * 0 = 0\r\n * 0 * N = N\r\n * 0 * I = N\r\n * N * n = N\r\n * N * 0 = N\r\n * N * N = N\r\n * N * I = N\r\n * I * n = I\r\n * I * 0 = N\r\n * I * N = N\r\n * I * I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n * of BigNumber(y, b).\r\n */\r\n P.multipliedBy = P.times = function (y, b) {\r\n var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n base, sqrtBase,\r\n x = this,\r\n xc = x.c,\r\n yc = (y = new BigNumber(y, b)).c;\r\n\r\n // Either NaN, ±Infinity or ±0?\r\n if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n y.c = y.e = y.s = null;\r\n } else {\r\n y.s *= x.s;\r\n\r\n // Return ±Infinity if either is ±Infinity.\r\n if (!xc || !yc) {\r\n y.c = y.e = null;\r\n\r\n // Return ±0 if either is ±0.\r\n } else {\r\n y.c = [0];\r\n y.e = 0;\r\n }\r\n }\r\n\r\n return y;\r\n }\r\n\r\n e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n y.s *= x.s;\r\n xcL = xc.length;\r\n ycL = yc.length;\r\n\r\n // Ensure xc points to longer array and xcL to its length.\r\n if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n // Initialise the result array with zeros.\r\n for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n base = BASE;\r\n sqrtBase = SQRT_BASE;\r\n\r\n for (i = ycL; --i >= 0;) {\r\n c = 0;\r\n ylo = yc[i] % sqrtBase;\r\n yhi = yc[i] / sqrtBase | 0;\r\n\r\n for (k = xcL, j = i + k; j > i;) {\r\n xlo = xc[--k] % sqrtBase;\r\n xhi = xc[k] / sqrtBase | 0;\r\n m = yhi * xlo + xhi * ylo;\r\n xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n zc[j--] = xlo % base;\r\n }\r\n\r\n zc[j] = c;\r\n }\r\n\r\n if (c) {\r\n ++e;\r\n } else {\r\n zc.splice(0, 1);\r\n }\r\n\r\n return normalise(y, zc, e);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n * i.e. multiplied by -1.\r\n */\r\n P.negated = function () {\r\n var x = new BigNumber(this);\r\n x.s = -x.s || null;\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * n + 0 = n\r\n * n + N = N\r\n * n + I = I\r\n * 0 + n = n\r\n * 0 + 0 = 0\r\n * 0 + N = N\r\n * 0 + I = I\r\n * N + n = N\r\n * N + 0 = N\r\n * N + N = N\r\n * N + I = N\r\n * I + n = I\r\n * I + 0 = I\r\n * I + N = N\r\n * I + I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n * BigNumber(y, b).\r\n */\r\n P.plus = function (y, b) {\r\n var t,\r\n x = this,\r\n a = x.s;\r\n\r\n y = new BigNumber(y, b);\r\n b = y.s;\r\n\r\n // Either NaN?\r\n if (!a || !b) return new BigNumber(NaN);\r\n\r\n // Signs differ?\r\n if (a != b) {\r\n y.s = -b;\r\n return x.minus(y);\r\n }\r\n\r\n var xe = x.e / LOG_BASE,\r\n ye = y.e / LOG_BASE,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n if (!xe || !ye) {\r\n\r\n // Return ±Infinity if either ±Infinity.\r\n if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n // Either zero?\r\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n }\r\n\r\n xe = bitFloor(xe);\r\n ye = bitFloor(ye);\r\n xc = xc.slice();\r\n\r\n // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n if (a = xe - ye) {\r\n if (a > 0) {\r\n ye = xe;\r\n t = yc;\r\n } else {\r\n a = -a;\r\n t = xc;\r\n }\r\n\r\n t.reverse();\r\n for (; a--; t.push(0));\r\n t.reverse();\r\n }\r\n\r\n a = xc.length;\r\n b = yc.length;\r\n\r\n // Point xc to the longer array, and b to the shorter length.\r\n if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n for (a = 0; b;) {\r\n a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n }\r\n\r\n if (a) {\r\n xc = [a].concat(xc);\r\n ++ye;\r\n }\r\n\r\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n // ye = MAX_EXP + 1 possible\r\n return normalise(y, xc, ye);\r\n };\r\n\r\n\r\n /*\r\n * If sd is undefined or null or true or false, return the number of significant digits of\r\n * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n * If sd is true include integer-part trailing zeros in the count.\r\n *\r\n * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n * boolean: whether to count integer-part trailing zeros: true or false.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\r\n P.precision = P.sd = function (sd, rm) {\r\n var c, n, v,\r\n x = this;\r\n\r\n if (sd != null && sd !== !!sd) {\r\n intCheck(sd, 1, MAX);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n return round(new BigNumber(x), sd, rm);\r\n }\r\n\r\n if (!(c = x.c)) return null;\r\n v = c.length - 1;\r\n n = v * LOG_BASE + 1;\r\n\r\n if (v = c[v]) {\r\n\r\n // Subtract the number of trailing zeros of the last element.\r\n for (; v % 10 == 0; v /= 10, n--);\r\n\r\n // Add the number of digits of the first element.\r\n for (v = c[0]; v >= 10; v /= 10, n++);\r\n }\r\n\r\n if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n return n;\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n *\r\n * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n */\r\n P.shiftedBy = function (k) {\r\n intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n return this.times('1e' + k);\r\n };\r\n\r\n\r\n /*\r\n * sqrt(-n) = N\r\n * sqrt(N) = N\r\n * sqrt(-I) = N\r\n * sqrt(I) = I\r\n * sqrt(0) = 0\r\n * sqrt(-0) = -0\r\n *\r\n * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\r\n P.squareRoot = P.sqrt = function () {\r\n var m, n, r, rep, t,\r\n x = this,\r\n c = x.c,\r\n s = x.s,\r\n e = x.e,\r\n dp = DECIMAL_PLACES + 4,\r\n half = new BigNumber('0.5');\r\n\r\n // Negative/NaN/Infinity/zero?\r\n if (s !== 1 || !c || !c[0]) {\r\n return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n }\r\n\r\n // Initial estimate.\r\n s = Math.sqrt(+x);\r\n\r\n // Math.sqrt underflow/overflow?\r\n // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n if (s == 0 || s == 1 / 0) {\r\n n = coeffToString(c);\r\n if ((n.length + e) % 2 == 0) n += '0';\r\n s = Math.sqrt(n);\r\n e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n if (s == 1 / 0) {\r\n n = '1e' + e;\r\n } else {\r\n n = s.toExponential();\r\n n = n.slice(0, n.indexOf('e') + 1) + e;\r\n }\r\n\r\n r = new BigNumber(n);\r\n } else {\r\n r = new BigNumber(s + '');\r\n }\r\n\r\n // Check for zero.\r\n // r could be zero if MIN_EXP is changed after the this value was created.\r\n // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n // coeffToString to throw.\r\n if (r.c[0]) {\r\n e = r.e;\r\n s = e + dp;\r\n if (s < 3) s = 0;\r\n\r\n // Newton-Raphson iteration.\r\n for (; ;) {\r\n t = r;\r\n r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n if (coeffToString(t.c ).slice(0, s) === (n =\r\n coeffToString(r.c)).slice(0, s)) {\r\n\r\n // The exponent of r may here be one less than the final result exponent,\r\n // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n // are indexed correctly.\r\n if (r.e < e) --s;\r\n n = n.slice(s - 3, s + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n // iteration.\r\n if (n == '9999' || !rep && n == '4999') {\r\n\r\n // On the first iteration only, check to see if rounding up gives the\r\n // exact result as the nines may infinitely repeat.\r\n if (!rep) {\r\n round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n if (t.times(t).eq(x)) {\r\n r = t;\r\n break;\r\n }\r\n }\r\n\r\n dp += 4;\r\n s += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n // result. If not, then there are further digits and m will be truthy.\r\n if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n // Truncate to the first rounding digit.\r\n round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n m = !r.times(r).eq(x);\r\n }\r\n\r\n break;\r\n }\r\n }\r\n }\r\n }\r\n\r\n return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in exponential notation and\r\n * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toExponential = function (dp, rm) {\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n dp++;\r\n }\r\n return format(this, dp, rm, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toFixed = function (dp, rm) {\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n dp = dp + this.e + 1;\r\n }\r\n return format(this, dp, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n * of the FORMAT object (see BigNumber.set).\r\n *\r\n * FORMAT = {\r\n * decimalSeparator : '.',\r\n * groupSeparator : ',',\r\n * groupSize : 3,\r\n * secondaryGroupSize : 0,\r\n * fractionGroupSeparator : '\\xA0', // non-breaking space\r\n * fractionGroupSize : 0\r\n * };\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toFormat = function (dp, rm) {\r\n var str = this.toFixed(dp, rm);\r\n\r\n if (this.c) {\r\n var i,\r\n arr = str.split('.'),\r\n g1 = +FORMAT.groupSize,\r\n g2 = +FORMAT.secondaryGroupSize,\r\n groupSeparator = FORMAT.groupSeparator,\r\n intPart = arr[0],\r\n fractionPart = arr[1],\r\n isNeg = this.s < 0,\r\n intDigits = isNeg ? intPart.slice(1) : intPart,\r\n len = intDigits.length;\r\n\r\n if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n if (g1 > 0 && len > 0) {\r\n i = len % g1 || g1;\r\n intPart = intDigits.substr(0, i);\r\n\r\n for (; i < len; i += g1) {\r\n intPart += groupSeparator + intDigits.substr(i, g1);\r\n }\r\n\r\n if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n if (isNeg) intPart = '-' + intPart;\r\n }\r\n\r\n str = fractionPart\r\n ? intPart + FORMAT.decimalSeparator + ((g2 = +FORMAT.fractionGroupSize)\r\n ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n '$&' + FORMAT.fractionGroupSeparator)\r\n : fractionPart)\r\n : intPart;\r\n }\r\n\r\n return str;\r\n };\r\n\r\n\r\n /*\r\n * Return a string array representing the value of this BigNumber as a simple fraction with\r\n * an integer numerator and an integer denominator. The denominator will be a positive\r\n * non-zero value less than or equal to the specified maximum denominator. If a maximum\r\n * denominator is not specified, the denominator will be the lowest value necessary to\r\n * represent the number exactly.\r\n *\r\n * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n *\r\n * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n */\r\n P.toFraction = function (md) {\r\n var arr, d, d0, d1, d2, e, exp, n, n0, n1, q, s,\r\n x = this,\r\n xc = x.c;\r\n\r\n if (md != null) {\r\n n = new BigNumber(md);\r\n\r\n // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n throw Error\r\n (bignumberError + 'Argument ' +\r\n (n.isInteger() ? 'out of range: ' : 'not an integer: ') + md);\r\n }\r\n }\r\n\r\n if (!xc) return x.toString();\r\n\r\n d = new BigNumber(ONE);\r\n n1 = d0 = new BigNumber(ONE);\r\n d1 = n0 = new BigNumber(ONE);\r\n s = coeffToString(xc);\r\n\r\n // Determine initial denominator.\r\n // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n e = d.e = s.length - x.e - 1;\r\n d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n exp = MAX_EXP;\r\n MAX_EXP = 1 / 0;\r\n n = new BigNumber(s);\r\n\r\n // n0 = d1 = 0\r\n n0.c[0] = 0;\r\n\r\n for (; ;) {\r\n q = div(n, d, 0, 1);\r\n d2 = d0.plus(q.times(d1));\r\n if (d2.comparedTo(md) == 1) break;\r\n d0 = d1;\r\n d1 = d2;\r\n n1 = n0.plus(q.times(d2 = n1));\r\n n0 = d2;\r\n d = n.minus(q.times(d2 = d));\r\n n = d2;\r\n }\r\n\r\n d2 = div(md.minus(d0), d1, 0, 1);\r\n n0 = n0.plus(d2.times(n1));\r\n d0 = d0.plus(d2.times(d1));\r\n n0.s = n1.s = x.s;\r\n e *= 2;\r\n\r\n // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n arr = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1\r\n ? [n1.toString(), d1.toString()]\r\n : [n0.toString(), d0.toString()];\r\n\r\n MAX_EXP = exp;\r\n return arr;\r\n };\r\n\r\n\r\n /*\r\n * Return the value of this BigNumber converted to a number primitive.\r\n */\r\n P.toNumber = function () {\r\n return +this;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n * necessary to represent the integer part of the value in fixed-point notation, then use\r\n * exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\r\n P.toPrecision = function (sd, rm) {\r\n if (sd != null) intCheck(sd, 1, MAX);\r\n return format(this, sd, rm, 2);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n * TO_EXP_NEG, return exponential notation.\r\n *\r\n * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n *\r\n * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n */\r\n P.toString = function (b) {\r\n var str,\r\n n = this,\r\n s = n.s,\r\n e = n.e;\r\n\r\n // Infinity or NaN?\r\n if (e === null) {\r\n\r\n if (s) {\r\n str = 'Infinity';\r\n if (s < 0) str = '-' + str;\r\n } else {\r\n str = 'NaN';\r\n }\r\n } else {\r\n str = coeffToString(n.c);\r\n\r\n if (b == null) {\r\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n ? toExponential(str, e)\r\n : toFixedPoint(str, e, '0');\r\n } else {\r\n intCheck(b, 2, ALPHABET.length, 'Base');\r\n str = convertBase(toFixedPoint(str, e, '0'), 10, b, s, true);\r\n }\r\n\r\n if (s < 0 && n.c[0]) str = '-' + str;\r\n }\r\n\r\n return str;\r\n };\r\n\r\n\r\n /*\r\n * Return as toString, but do not accept a base argument, and include the minus sign for\r\n * negative zero.\r\n */\r\n P.valueOf = P.toJSON = function () {\r\n var str,\r\n n = this,\r\n e = n.e;\r\n\r\n if (e === null) return n.toString();\r\n\r\n str = coeffToString(n.c);\r\n\r\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n ? toExponential(str, e)\r\n : toFixedPoint(str, e, '0');\r\n\r\n return n.s < 0 ? '-' + str : str;\r\n };\r\n\r\n\r\n P._isBigNumber = true;\r\n\r\n if (configObject != null) BigNumber.set(configObject);\r\n\r\n return BigNumber;\r\n }\r\n\r\n\r\n // PRIVATE HELPER FUNCTIONS\r\n\r\n\r\n function bitFloor(n) {\r\n var i = n | 0;\r\n return n > 0 || n === i ? i : i - 1;\r\n }\r\n\r\n\r\n // Return a coefficient array as a string of base 10 digits.\r\n function coeffToString(a) {\r\n var s, z,\r\n i = 1,\r\n j = a.length,\r\n r = a[0] + '';\r\n\r\n for (; i < j;) {\r\n s = a[i++] + '';\r\n z = LOG_BASE - s.length;\r\n for (; z--; s = '0' + s);\r\n r += s;\r\n }\r\n\r\n // Determine trailing zeros.\r\n for (j = r.length; r.charCodeAt(--j) === 48;);\r\n return r.slice(0, j + 1 || 1);\r\n }\r\n\r\n\r\n // Compare the value of BigNumbers x and y.\r\n function compare(x, y) {\r\n var a, b,\r\n xc = x.c,\r\n yc = y.c,\r\n i = x.s,\r\n j = y.s,\r\n k = x.e,\r\n l = y.e;\r\n\r\n // Either NaN?\r\n if (!i || !j) return null;\r\n\r\n a = xc && !xc[0];\r\n b = yc && !yc[0];\r\n\r\n // Either zero?\r\n if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n // Signs differ?\r\n if (i != j) return i;\r\n\r\n a = i < 0;\r\n b = k == l;\r\n\r\n // Either Infinity?\r\n if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n // Compare exponents.\r\n if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n // Compare digit by digit.\r\n for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n // Compare lengths.\r\n return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n }\r\n\r\n\r\n /*\r\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n */\r\n function intCheck(n, min, max, name) {\r\n if (n < min || n > max || n !== (n < 0 ? mathceil(n) : mathfloor(n))) {\r\n throw Error\r\n (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n : ' not a primitive number: ') + n);\r\n }\r\n }\r\n\r\n\r\n function isArray(obj) {\r\n return Object.prototype.toString.call(obj) == '[object Array]';\r\n }\r\n\r\n\r\n // Assumes finite n.\r\n function isOdd(n) {\r\n var k = n.c.length - 1;\r\n return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n }\r\n\r\n\r\n function toExponential(str, e) {\r\n return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n (e < 0 ? 'e' : 'e+') + e;\r\n }\r\n\r\n\r\n function toFixedPoint(str, e, z) {\r\n var len, zs;\r\n\r\n // Negative exponent?\r\n if (e < 0) {\r\n\r\n // Prepend zeros.\r\n for (zs = z + '.'; ++e; zs += z);\r\n str = zs + str;\r\n\r\n // Positive exponent\r\n } else {\r\n len = str.length;\r\n\r\n // Append zeros.\r\n if (++e > len) {\r\n for (zs = z, e -= len; --e; zs += z);\r\n str += zs;\r\n } else if (e < len) {\r\n str = str.slice(0, e) + '.' + str.slice(e);\r\n }\r\n }\r\n\r\n return str;\r\n }\r\n\r\n\r\n // EXPORT\r\n\r\n\r\n BigNumber = clone();\r\n BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n globalObject.BigNumber = BigNumber;\r\n})(Class.scope);\r\nconst BigNumber = Class.scope.BigNumber;\r\nBigNumber.config({ DECIMAL_PLACES: 11 });\r\n","class NumberUtils {\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint8(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT8_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint16(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT16_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint32(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT32_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint64(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT64_MAX;\r\n }\r\n\r\n /**\r\n * @param {BigNumber} val\r\n * @return {boolean}\r\n */\r\n static isUint128(val) {\r\n return val.isInteger() && val.gte(0) && val.lte(NumberUtils.UINT128_MAX);\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n static randomUint32() {\r\n return Math.floor(Math.random() * (NumberUtils.UINT32_MAX + 1));\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n static randomUint64() {\r\n return Math.floor(Math.random() * (NumberUtils.UINT64_MAX + 1));\r\n }\r\n\r\n /**\r\n * @param {string} bin\r\n * @return {number}\r\n */\r\n static fromBinary(bin) {\r\n return parseInt(bin, 2);\r\n }\r\n}\r\n\r\nNumberUtils.UINT8_MAX = 255;\r\nNumberUtils.UINT16_MAX = 65535;\r\nNumberUtils.UINT32_MAX = 4294967295;\r\nNumberUtils.UINT64_MAX = Number.MAX_SAFE_INTEGER;\r\nNumberUtils.UINT128_MAX = new BigNumber('ffffffffffffffffffffffffffffffff', 16);\r\n//Object.freeze(NumberUtils);\r\nClass.register(NumberUtils);\r\n","class MerkleTree {\r\n /**\r\n * @param {Array} values\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {Hash}\r\n */\r\n static computeRoot(values, fnHash = MerkleTree._hash) {\r\n return MerkleTree._computeRoot(values, fnHash);\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {function(o: *):Hash} fnHash\r\n * @returns {Hash}\r\n * @private\r\n */\r\n static _computeRoot(values, fnHash) {\r\n const len = values.length;\r\n if (len === 0) {\r\n return Hash.light(new Uint8Array(0));\r\n }\r\n if (len === 1) {\r\n return fnHash(values[0]);\r\n }\r\n\r\n const mid = Math.round(len / 2);\r\n const left = values.slice(0, mid);\r\n const right = values.slice(mid);\r\n const leftHash = MerkleTree._computeRoot(left, fnHash);\r\n const rightHash = MerkleTree._computeRoot(right, fnHash);\r\n return Hash.light(BufferUtils.concatTypedArrays(leftHash.serialize(), rightHash.serialize()));\r\n }\r\n\r\n /**\r\n * @param {Hash|Uint8Array|{hash: function():Hash}|{serialize: function():Uint8Array}} o\r\n * @returns {Hash}\r\n * @private\r\n */\r\n static _hash(o) {\r\n if (o instanceof Hash) {\r\n return o;\r\n }\r\n if (typeof o.hash === 'function') {\r\n return o.hash();\r\n }\r\n if (typeof o.serialize === 'function') {\r\n return Hash.light(o.serialize());\r\n }\r\n if (o instanceof Uint8Array) {\r\n return Hash.light(o);\r\n }\r\n throw new Error('MerkleTree objects must be Uint8Array or have a .hash()/.serialize() method');\r\n }\r\n}\r\nClass.register(MerkleTree);\r\n","class MerklePath {\r\n /**\r\n * @param {Array.<MerklePathNode>} nodes\r\n */\r\n constructor(nodes) {\r\n if (!Array.isArray(nodes) || !NumberUtils.isUint8(nodes.length)\r\n || nodes.some(it => !(it instanceof MerklePathNode))) throw new Error('Malformed nodes');\r\n /**\r\n * @type {Array.<MerklePathNode>}\r\n * @private\r\n */\r\n this._nodes = nodes;\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {*} leafValue\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {MerklePath}\r\n */\r\n static compute(values, leafValue, fnHash = MerkleTree._hash) {\r\n const leafHash = fnHash(leafValue);\r\n const path = [];\r\n MerklePath._compute(values, leafHash, path, fnHash);\r\n return new MerklePath(path);\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {Hash} leafHash\r\n * @param {Array.<MerklePathNode>} path\r\n * @param {function(o: *):Hash} fnHash\r\n * @returns {{containsLeaf:boolean, inner:Hash}}\r\n * @private\r\n */\r\n static _compute(values, leafHash, path, fnHash) {\r\n const len = values.length;\r\n let hash;\r\n if (len === 0) {\r\n hash = Hash.light(new Uint8Array(0));\r\n return {containsLeaf: false, inner: hash};\r\n }\r\n if (len === 1) {\r\n hash = fnHash(values[0]);\r\n return {containsLeaf: hash.equals(leafHash), inner: hash};\r\n }\r\n\r\n const mid = Math.round(len / 2);\r\n const left = values.slice(0, mid);\r\n const right = values.slice(mid);\r\n const {containsLeaf: leftLeaf, inner: leftHash} = MerklePath._compute(left, leafHash, path, fnHash);\r\n const {containsLeaf: rightLeaf, inner: rightHash} = MerklePath._compute(right, leafHash, path, fnHash);\r\n hash = Hash.light(BufferUtils.concatTypedArrays(leftHash.serialize(), rightHash.serialize()));\r\n\r\n if (leftLeaf) {\r\n path.push(new MerklePathNode(rightHash, false));\r\n return {containsLeaf: true, inner: hash};\r\n } else if (rightLeaf) {\r\n path.push(new MerklePathNode(leftHash, true));\r\n return {containsLeaf: true, inner: hash};\r\n }\r\n\r\n return {containsLeaf: false, inner: hash};\r\n }\r\n\r\n /**\r\n * @param {*} leafValue\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {Hash}\r\n */\r\n computeRoot(leafValue, fnHash = MerkleTree._hash) {\r\n /** @type {Hash} */\r\n let root = fnHash(leafValue);\r\n for (const node of this._nodes) {\r\n const left = node.left;\r\n const hash = node.hash;\r\n const concat = new SerialBuffer(hash.serializedSize * 2);\r\n if (left) hash.serialize(concat);\r\n root.serialize(concat);\r\n if (!left) hash.serialize(concat);\r\n root = Hash.light(concat);\r\n }\r\n return root;\r\n }\r\n\r\n /**\r\n * @param {Array.<MerklePathNode>} nodes\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _compress(nodes) {\r\n const count = nodes.length;\r\n const leftBitsSize = Math.ceil(count / 8);\r\n const leftBits = new Uint8Array(leftBitsSize);\r\n\r\n for (let i = 0; i < count; i++) {\r\n if (nodes[i].left) {\r\n leftBits[Math.floor(i / 8)] |= 0x80 >>> (i % 8);\r\n }\r\n }\r\n\r\n return leftBits;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @returns {MerklePath}\r\n */\r\n static unserialize(buf) {\r\n const count = buf.readUint8();\r\n const leftBitsSize = Math.ceil(count / 8);\r\n const leftBits = buf.read(leftBitsSize);\r\n\r\n const nodes = [];\r\n for (let i = 0; i < count; i++) {\r\n const left = (leftBits[Math.floor(i / 8)] & (0x80 >>> (i % 8))) !== 0;\r\n const algorithm = buf.readUint8();\r\n const hash = Hash.unserialize(buf, algorithm);\r\n nodes.push(new MerklePathNode(hash, left));\r\n }\r\n return new MerklePath(nodes);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(this._nodes.length);\r\n buf.write(MerklePath._compress(this._nodes));\r\n\r\n for (const node of this._nodes) {\r\n buf.writeUint8(node.hash.algorithm);\r\n node.hash.serialize(buf);\r\n }\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n const leftBitsSize = Math.ceil(this._nodes.length / 8);\r\n return /*count*/ 1\r\n + leftBitsSize\r\n + this._nodes.reduce((sum, node) => sum + /*algorithm*/ 1 + node.hash.serializedSize, 0);\r\n }\r\n\r\n /**\r\n * @param {MerklePath} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof MerklePath\r\n && this._nodes.length === o._nodes.length\r\n && this._nodes.every((node, i) => node.equals(o._nodes[i]));\r\n }\r\n\r\n /** @type {Array.<MerklePathNode>} */\r\n get nodes() {\r\n return this._nodes;\r\n }\r\n}\r\nClass.register(MerklePath);\r\n\r\nclass MerklePathNode {\r\n /**\r\n * @param {Hash} hash\r\n * @param {boolean} left\r\n */\r\n constructor(hash, left) {\r\n this._hash = hash;\r\n this._left = left;\r\n }\r\n\r\n /** @type {Hash} */\r\n get hash() {\r\n return this._hash;\r\n }\r\n\r\n /** @type {boolean} */\r\n get left() {\r\n return this._left;\r\n }\r\n\r\n /**\r\n * @param {MerklePathNode} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof MerklePathNode\r\n && this._hash.equals(o.hash)\r\n && this._left === o.left;\r\n }\r\n}\r\nClass.register(MerklePathNode);\r\n","class MnemonicUtils {\r\n // Adapted from https://github.com/bitcoinjs/bip39, see license below.\r\n\r\n /**\r\n * @param {Uint8Array} entropy\r\n * @returns {string}\r\n * @private\r\n */\r\n static _crcChecksum(entropy) {\r\n const ENT = entropy.length * 8;\r\n const CS = ENT / 32;\r\n const hash = CRC8.compute(entropy);\r\n\r\n return BufferUtils.toBinary([hash]).slice(0, CS);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} entropy\r\n * @returns {string}\r\n * @private\r\n */\r\n static _sha256Checksum(entropy) {\r\n const ENT = entropy.length * 8;\r\n const CS = ENT / 32;\r\n const hash = Hash.computeSha256(entropy);\r\n\r\n return BufferUtils.toBinary(hash).slice(0, CS);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} entropy\r\n * @returns {string}\r\n * @private\r\n */\r\n static _entropyToBits(entropy) {\r\n // 128 <= ENT <= 256\r\n if (entropy.length < 16) throw new Error('Invalid key, length < 16');\r\n if (entropy.length > 32) throw new Error('Invalid key, length > 32');\r\n if (entropy.length % 4 !== 0) throw new Error('Invalid key, length % 4 != 0');\r\n\r\n return BufferUtils.toBinary(entropy);\r\n }\r\n\r\n /**\r\n * @param {string|ArrayBuffer|Uint8Array|Entropy} entropy\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _normalizeEntropy(entropy) {\r\n if (typeof entropy === 'string') entropy = BufferUtils.fromHex(entropy);\r\n if (entropy instanceof Entropy) entropy = entropy.serialize();\r\n if (entropy instanceof ArrayBuffer) entropy = new Uint8Array(entropy);\r\n return entropy;\r\n }\r\n\r\n /**\r\n * @param {string} bits\r\n * @param {Array.<string>} wordlist\r\n * @returns {Array.<string>}\r\n */\r\n static _bitsToMnemonic(bits, wordlist) {\r\n const chunks = bits.match(/(.{11})/g);\r\n const words = chunks.map(chunk => {\r\n const index = NumberUtils.fromBinary(chunk);\r\n return wordlist[index];\r\n });\r\n\r\n return words;\r\n }\r\n\r\n /**\r\n * @param {Array.<string>} mnemonic\r\n * @param {Array.<string>} wordlist\r\n * @returns {string}\r\n */\r\n static _mnemonicToBits(mnemonic, wordlist) {\r\n const words = mnemonic;\r\n if (words.length < 12) throw new Error('Invalid mnemonic, less than 12 words');\r\n if (words.length > 24) throw new Error('Invalid mnemonic, more than 24 words');\r\n if (words.length % 3 !== 0) throw new Error('Invalid mnemonic, words % 3 != 0');\r\n\r\n // Convert word indices to 11 bit binary strings\r\n const bits = words.map(function (word) {\r\n const index = wordlist.indexOf(word.toLowerCase());\r\n if (index === -1) throw new Error(`Invalid mnemonic, word >${word}< is not in wordlist`);\r\n\r\n return StringUtils.lpad(index.toString(2), '0', 11);\r\n }).join('');\r\n\r\n return bits;\r\n }\r\n\r\n /**\r\n * @param {string} bits\r\n * @param {boolean} legacy\r\n * @returns {Uint8Array}\r\n */\r\n static _bitsToEntropy(bits, legacy = false) {\r\n // Split the binary string into ENT/CS\r\n const dividerIndex = bits.length - (bits.length % 8 || 8);\r\n const entropyBits = bits.slice(0, dividerIndex);\r\n const checksumBits = bits.slice(dividerIndex);\r\n\r\n // Calculate the checksum and compare\r\n const entropyBytes = entropyBits.match(/(.{8})/g).map(NumberUtils.fromBinary);\r\n\r\n if (entropyBytes.length < 16) throw new Error('Invalid generated key, length < 16');\r\n if (entropyBytes.length > 32) throw new Error('Invalid generated key, length > 32');\r\n if (entropyBytes.length % 4 !== 0) throw new Error('Invalid generated key, length % 4 != 0');\r\n\r\n const entropy = new Uint8Array(entropyBytes);\r\n const checksum = legacy ? MnemonicUtils._crcChecksum(entropy) : MnemonicUtils._sha256Checksum(entropy);\r\n if (checksum !== checksumBits) throw new Error('Invalid checksum');\r\n\r\n return entropy;\r\n }\r\n\r\n /**\r\n * @param {string|ArrayBuffer|Uint8Array|Entropy} entropy\r\n * @param {Array.<string>} [wordlist]\r\n * @returns {Array.<string>}\r\n */\r\n static entropyToMnemonic(entropy, wordlist) {\r\n wordlist = wordlist || MnemonicUtils.DEFAULT_WORDLIST;\r\n entropy = MnemonicUtils._normalizeEntropy(entropy);\r\n\r\n const entropyBits = MnemonicUtils._entropyToBits(entropy);\r\n const checksumBits = MnemonicUtils._sha256Checksum(entropy);\r\n\r\n const bits = entropyBits + checksumBits;\r\n return MnemonicUtils._bitsToMnemonic(bits, wordlist);\r\n }\r\n\r\n /**\r\n * @param {string|ArrayBuffer|Uint8Array|Entropy} entropy\r\n * @param {Array.<string>} [wordlist]\r\n * @returns {Array.<string>}\r\n * @deprecated\r\n */\r\n static entropyToLegacyMnemonic(entropy, wordlist) {\r\n wordlist = wordlist || MnemonicUtils.DEFAULT_WORDLIST;\r\n entropy = MnemonicUtils._normalizeEntropy(entropy);\r\n\r\n const entropyBits = MnemonicUtils._entropyToBits(entropy);\r\n const checksumBits = MnemonicUtils._crcChecksum(entropy);\r\n\r\n const bits = entropyBits + checksumBits;\r\n return MnemonicUtils._bitsToMnemonic(bits, wordlist);\r\n }\r\n\r\n /**\r\n * @param {Array.<string>|string} mnemonic\r\n * @param {Array.<string>} [wordlist]\r\n * @returns {Entropy}\r\n */\r\n static mnemonicToEntropy(mnemonic, wordlist) {\r\n if (!Array.isArray(mnemonic)) mnemonic = mnemonic.trim().split(/\\s+/g);\r\n wordlist = wordlist || MnemonicUtils.DEFAULT_WORDLIST;\r\n\r\n const bits = MnemonicUtils._mnemonicToBits(mnemonic, wordlist);\r\n return new Entropy(MnemonicUtils._bitsToEntropy(bits, false));\r\n }\r\n\r\n /**\r\n * @param {Array.<string>|string} mnemonic\r\n * @param {Array.<string>} [wordlist]\r\n * @returns {Entropy}\r\n * @deprecated\r\n */\r\n static legacyMnemonicToEntropy(mnemonic, wordlist) {\r\n if (!Array.isArray(mnemonic)) mnemonic = mnemonic.trim().split(/\\s+/g);\r\n wordlist = wordlist || MnemonicUtils.DEFAULT_WORDLIST;\r\n\r\n const bits = MnemonicUtils._mnemonicToBits(mnemonic, wordlist);\r\n return new Entropy(MnemonicUtils._bitsToEntropy(bits, true));\r\n }\r\n\r\n /**\r\n * @param {string} password\r\n * @returns {string}\r\n * @private\r\n */\r\n static _salt(password) {\r\n return `mnemonic${password || ''}`;\r\n }\r\n\r\n /**\r\n * @param {string|Array.<string>} mnemonic\r\n * @param {string} [password]\r\n * @returns {SerialBuffer}\r\n */\r\n static mnemonicToSeed(mnemonic, password) {\r\n if (Array.isArray(mnemonic)) mnemonic = mnemonic.join(' ');\r\n\r\n const mnemonicBuffer = BufferUtils.fromAscii(mnemonic);\r\n const saltBuffer = BufferUtils.fromAscii(MnemonicUtils._salt(password));\r\n\r\n return CryptoUtils.computePBKDF2sha512(mnemonicBuffer, saltBuffer, 2048, 64);\r\n }\r\n\r\n /**\r\n * @param {string|Array.<string>} mnemonic\r\n * @param {string} [password]\r\n * @returns {ExtendedPrivateKey}\r\n */\r\n static mnemonicToExtendedPrivateKey(mnemonic, password) {\r\n const seed = MnemonicUtils.mnemonicToSeed(mnemonic, password);\r\n return ExtendedPrivateKey.generateMasterKey(seed);\r\n }\r\n\r\n /**\r\n * @param {Entropy} entropy\r\n * @returns {boolean}\r\n */\r\n static isCollidingChecksum(entropy) {\r\n const normalizedEntropy = MnemonicUtils._normalizeEntropy(entropy);\r\n return MnemonicUtils._crcChecksum(normalizedEntropy) === MnemonicUtils._sha256Checksum(normalizedEntropy);\r\n }\r\n\r\n /**\r\n * @param {string|Array.<string>} mnemonic\r\n * @param {Array.<string>} [wordlist]\r\n * @returns {MnemonicUtils.MnemonicType}\r\n */\r\n static getMnemonicType(mnemonic, wordlist) {\r\n if (!Array.isArray(mnemonic)) mnemonic = mnemonic.trim().split(/\\s+/g);\r\n\r\n wordlist = wordlist || MnemonicUtils.DEFAULT_WORDLIST;\r\n\r\n const bits = MnemonicUtils._mnemonicToBits(mnemonic, wordlist);\r\n\r\n let isBIP39 = true;\r\n try { MnemonicUtils._bitsToEntropy(bits, false); } catch (e) { isBIP39 = false; }\r\n let isLegacy = true;\r\n try { MnemonicUtils._bitsToEntropy(bits, true); } catch (e) { isLegacy = false; }\r\n\r\n if (isBIP39 && isLegacy) return MnemonicUtils.MnemonicType.UNKNOWN;\r\n if (!isBIP39 && !isLegacy) throw new Error('Invalid checksum');\r\n return isBIP39 ? MnemonicUtils.MnemonicType.BIP39 : MnemonicUtils.MnemonicType.LEGACY;\r\n }\r\n}\r\n\r\nMnemonicUtils.ENGLISH_WORDLIST = ['abandon', 'ability', 'able', 'about', 'above', 'absent', 'absorb', 'abstract', 'absurd', 'abuse', 'access', 'accident', 'account', 'accuse', 'achieve', 'acid', 'acoustic', 'acquire', 'across', 'act', 'action', 'actor', 'actress', 'actual', 'adapt', 'add', 'addict', 'address', 'adjust', 'admit', 'adult', 'advance', 'advice', 'aerobic', 'affair', 'afford', 'afraid', 'again', 'age', 'agent', 'agree', 'ahead', 'aim', 'air', 'airport', 'aisle', 'alarm', 'album', 'alcohol', 'alert', 'alien', 'all', 'alley', 'allow', 'almost', 'alone', 'alpha', 'already', 'also', 'alter', 'always', 'amateur', 'amazing', 'among', 'amount', 'amused', 'analyst', 'anchor', 'ancient', 'anger', 'angle', 'angry', 'animal', 'ankle', 'announce', 'annual', 'another', 'answer', 'antenna', 'antique', 'anxiety', 'any', 'apart', 'apology', 'appear', 'apple', 'approve', 'april', 'arch', 'arctic', 'area', 'arena', 'argue', 'arm', 'armed', 'armor', 'army', 'around', 'arrange', 'arrest', 'arrive', 'arrow', 'art', 'artefact', 'artist', 'artwork', 'ask', 'aspect', 'assault', 'asset', 'assist', 'assume', 'asthma', 'athlete', 'atom', 'attack', 'attend', 'attitude', 'attract', 'auction', 'audit', 'august', 'aunt', 'author', 'auto', 'autumn', 'average', 'avocado', 'avoid', 'awake', 'aware', 'away', 'awesome', 'awful', 'awkward', 'axis', 'baby', 'bachelor', 'bacon', 'badge', 'bag', 'balance', 'balcony', 'ball', 'bamboo', 'banana', 'banner', 'bar', 'barely', 'bargain', 'barrel', 'base', 'basic', 'basket', 'battle', 'beach', 'bean', 'beauty', 'because', 'become', 'beef', 'before', 'begin', 'behave', 'behind', 'believe', 'below', 'belt', 'bench', 'benefit', 'best', 'betray', 'better', 'between', 'beyond', 'bicycle', 'bid', 'bike', 'bind', 'biology', 'bird', 'birth', 'bitter', 'black', 'blade', 'blame', 'blanket', 'blast', 'bleak', 'bless', 'blind', 'blood', 'blossom', 'blouse', 'blue', 'blur', 'blush', 'board', 'boat', 'body', 'boil', 'bomb', 'bone', 'bonus', 'book', 'boost', 'border', 'boring', 'borrow', 'boss', 'bottom', 'bounce', 'box', 'boy', 'bracket', 'brain', 'brand', 'brass', 'brave', 'bread', 'breeze', 'brick', 'bridge', 'brief', 'bright', 'bring', 'brisk', 'broccoli', 'broken', 'bronze', 'broom', 'brother', 'brown', 'brush', 'bubble', 'buddy', 'budget', 'buffalo', 'build', 'bulb', 'bulk', 'bullet', 'bundle', 'bunker', 'burden', 'burger', 'burst', 'bus', 'business', 'busy', 'butter', 'buyer', 'buzz', 'cabbage', 'cabin', 'cable', 'cactus', 'cage', 'cake', 'call', 'calm', 'camera', 'camp', 'can', 'canal', 'cancel', 'candy', 'cannon', 'canoe', 'canvas', 'canyon', 'capable', 'capital', 'captain', 'car', 'carbon', 'card', 'cargo', 'carpet', 'carry', 'cart', 'case', 'cash', 'casino', 'castle', 'casual', 'cat', 'catalog', 'catch', 'category', 'cattle', 'caught', 'cause', 'caution', 'cave', 'ceiling', 'celery', 'cement', 'census', 'century', 'cereal', 'certain', 'chair', 'chalk', 'champion', 'change', 'chaos', 'chapter', 'charge', 'chase', 'chat', 'cheap', 'check', 'cheese', 'chef', 'cherry', 'chest', 'chicken', 'chief', 'child', 'chimney', 'choice', 'choose', 'chronic', 'chuckle', 'chunk', 'churn', 'cigar', 'cinnamon', 'circle', 'citizen', 'city', 'civil', 'claim', 'clap', 'clarify', 'claw', 'clay', 'clean', 'clerk', 'clever', 'click', 'client', 'cliff', 'climb', 'clinic', 'clip', 'clock', 'clog', 'close', 'cloth', 'cloud', 'clown', 'club', 'clump', 'cluster', 'clutch', 'coach', 'coast', 'coconut', 'code', 'coffee', 'coil', 'coin', 'collect', 'color', 'column', 'combine', 'come', 'comfort', 'comic', 'common', 'company', 'concert', 'conduct', 'confirm', 'congress', 'connect', 'consider', 'control', 'convince', 'cook', 'cool', 'copper', 'copy', 'coral', 'core', 'corn', 'correct', 'cost', 'cotton', 'couch', 'country', 'couple', 'course', 'cousin', 'cover', 'coyote', 'crack', 'cradle', 'craft', 'cram', 'crane', 'crash', 'crater', 'crawl', 'crazy', 'cream', 'credit', 'creek', 'crew', 'cricket', 'crime', 'crisp', 'critic', 'crop', 'cross', 'crouch', 'crowd', 'crucial', 'cruel', 'cruise', 'crumble', 'crunch', 'crush', 'cry', 'crystal', 'cube', 'culture', 'cup', 'cupboard', 'curious', 'current', 'curtain', 'curve', 'cushion', 'custom', 'cute', 'cycle', 'dad', 'damage', 'damp', 'dance', 'danger', 'daring', 'dash', 'daughter', 'dawn', 'day', 'deal', 'debate', 'debris', 'decade', 'december', 'decide', 'decline', 'decorate', 'decrease', 'deer', 'defense', 'define', 'defy', 'degree', 'delay', 'deliver', 'demand', 'demise', 'denial', 'dentist', 'deny', 'depart', 'depend', 'deposit', 'depth', 'deputy', 'derive', 'describe', 'desert', 'design', 'desk', 'despair', 'destroy', 'detail', 'detect', 'develop', 'device', 'devote', 'diagram', 'dial', 'diamond', 'diary', 'dice', 'diesel', 'diet', 'differ', 'digital', 'dignity', 'dilemma', 'dinner', 'dinosaur', 'direct', 'dirt', 'disagree', 'discover', 'disease', 'dish', 'dismiss', 'disorder', 'display', 'distance', 'divert', 'divide', 'divorce', 'dizzy', 'doctor', 'document', 'dog', 'doll', 'dolphin', 'domain', 'donate', 'donkey', 'donor', 'door', 'dose', 'double', 'dove', 'draft', 'dragon', 'drama', 'drastic', 'draw', 'dream', 'dress', 'drift', 'drill', 'drink', 'drip', 'drive', 'drop', 'drum', 'dry', 'duck', 'dumb', 'dune', 'during', 'dust', 'dutch', 'duty', 'dwarf', 'dynamic', 'eager', 'eagle', 'early', 'earn', 'earth', 'easily', 'east', 'easy', 'echo', 'ecology', 'economy', 'edge', 'edit', 'educate', 'effort', 'egg', 'eight', 'either', 'elbow', 'elder', 'electric', 'elegant', 'element', 'elephant', 'elevator', 'elite', 'else', 'embark', 'embody', 'embrace', 'emerge', 'emotion', 'employ', 'empower', 'empty', 'enable', 'enact', 'end', 'endless', 'endorse', 'enemy', 'energy', 'enforce', 'engage', 'engine', 'enhance', 'enjoy', 'enlist', 'enough', 'enrich', 'enroll', 'ensure', 'enter', 'entire', 'entry', 'envelope', 'episode', 'equal', 'equip', 'era', 'erase', 'erode', 'erosion', 'error', 'erupt', 'escape', 'essay', 'essence', 'estate', 'eternal', 'ethics', 'evidence', 'evil', 'evoke', 'evolve', 'exact', 'example', 'excess', 'exchange', 'excite', 'exclude', 'excuse', 'execute', 'exercise', 'exhaust', 'exhibit', 'exile', 'exist', 'exit', 'exotic', 'expand', 'expect', 'expire', 'explain', 'expose', 'express', 'extend', 'extra', 'eye', 'eyebrow', 'fabric', 'face', 'faculty', 'fade', 'faint', 'faith', 'fall', 'false', 'fame', 'family', 'famous', 'fan', 'fancy', 'fantasy', 'farm', 'fashion', 'fat', 'fatal', 'father', 'fatigue', 'fault', 'favorite', 'feature', 'february', 'federal', 'fee', 'feed', 'feel', 'female', 'fence', 'festival', 'fetch', 'fever', 'few', 'fiber', 'fiction', 'field', 'figure', 'file', 'film', 'filter', 'final', 'find', 'fine', 'finger', 'finish', 'fire', 'firm', 'first', 'fiscal', 'fish', 'fit', 'fitness', 'fix', 'flag', 'flame', 'flash', 'flat', 'flavor', 'flee', 'flight', 'flip', 'float', 'flock', 'floor', 'flower', 'fluid', 'flush', 'fly', 'foam', 'focus', 'fog', 'foil', 'fold', 'follow', 'food', 'foot', 'force', 'forest', 'forget', 'fork', 'fortune', 'forum', 'forward', 'fossil', 'foster', 'found', 'fox', 'fragile', 'frame', 'frequent', 'fresh', 'friend', 'fringe', 'frog', 'front', 'frost', 'frown', 'frozen', 'fruit', 'fuel', 'fun', 'funny', 'furnace', 'fury', 'future', 'gadget', 'gain', 'galaxy', 'gallery', 'game', 'gap', 'garage', 'garbage', 'garden', 'garlic', 'garment', 'gas', 'gasp', 'gate', 'gather', 'gauge', 'gaze', 'general', 'genius', 'genre', 'gentle', 'genuine', 'gesture', 'ghost', 'giant', 'gift', 'giggle', 'ginger', 'giraffe', 'girl', 'give', 'glad', 'glance', 'glare', 'glass', 'glide', 'glimpse', 'globe', 'gloom', 'glory', 'glove', 'glow', 'glue', 'goat', 'goddess', 'gold', 'good', 'goose', 'gorilla', 'gospel', 'gossip', 'govern', 'gown', 'grab', 'grace', 'grain', 'grant', 'grape', 'grass', 'gravity', 'great', 'green', 'grid', 'grief', 'grit', 'grocery', 'group', 'grow', 'grunt', 'guard', 'guess', 'guide', 'guilt', 'guitar', 'gun', 'gym', 'habit', 'hair', 'half', 'hammer', 'hamster', 'hand', 'happy', 'harbor', 'hard', 'harsh', 'harvest', 'hat', 'have', 'hawk', 'hazard', 'head', 'health', 'heart', 'heavy', 'hedgehog', 'height', 'hello', 'helmet', 'help', 'hen', 'hero', 'hidden', 'high', 'hill', 'hint', 'hip', 'hire', 'history', 'hobby', 'hockey', 'hold', 'hole', 'holiday', 'hollow', 'home', 'honey', 'hood', 'hope', 'horn', 'horror', 'horse', 'hospital', 'host', 'hotel', 'hour', 'hover', 'hub', 'huge', 'human', 'humble', 'humor', 'hundred', 'hungry', 'hunt', 'hurdle', 'hurry', 'hurt', 'husband', 'hybrid', 'ice', 'icon', 'idea', 'identify', 'idle', 'ignore', 'ill', 'illegal', 'illness', 'image', 'imitate', 'immense', 'immune', 'impact', 'impose', 'improve', 'impulse', 'inch', 'include', 'income', 'increase', 'index', 'indicate', 'indoor', 'industry', 'infant', 'inflict', 'inform', 'inhale', 'inherit', 'initial', 'inject', 'injury', 'inmate', 'inner', 'innocent', 'input', 'inquiry', 'insane', 'insect', 'inside', 'inspire', 'install', 'intact', 'interest', 'into', 'invest', 'invite', 'involve', 'iron', 'island', 'isolate', 'issue', 'item', 'ivory', 'jacket', 'jaguar', 'jar', 'jazz', 'jealous', 'jeans', 'jelly', 'jewel', 'job', 'join', 'joke', 'journey', 'joy', 'judge', 'juice', 'jump', 'jungle', 'junior', 'junk', 'just', 'kangaroo', 'keen', 'keep', 'ketchup', 'key', 'kick', 'kid', 'kidney', 'kind', 'kingdom', 'kiss', 'kit', 'kitchen', 'kite', 'kitten', 'kiwi', 'knee', 'knife', 'knock', 'know', 'lab', 'label', 'labor', 'ladder', 'lady', 'lake', 'lamp', 'language', 'laptop', 'large', 'later', 'latin', 'laugh', 'laundry', 'lava', 'law', 'lawn', 'lawsuit', 'layer', 'lazy', 'leader', 'leaf', 'learn', 'leave', 'lecture', 'left', 'leg', 'legal', 'legend', 'leisure', 'lemon', 'lend', 'length', 'lens', 'leopard', 'lesson', 'letter', 'level', 'liar', 'liberty', 'library', 'license', 'life', 'lift', 'light', 'like', 'limb', 'limit', 'link', 'lion', 'liquid', 'list', 'little', 'live', 'lizard', 'load', 'loan', 'lobster', 'local', 'lock', 'logic', 'lonely', 'long', 'loop', 'lottery', 'loud', 'lounge', 'love', 'loyal', 'lucky', 'luggage', 'lumber', 'lunar', 'lunch', 'luxury', 'lyrics', 'machine', 'mad', 'magic', 'magnet', 'maid', 'mail', 'main', 'major', 'make', 'mammal', 'man', 'manage', 'mandate', 'mango', 'mansion', 'manual', 'maple', 'marble', 'march', 'margin', 'marine', 'market', 'marriage', 'mask', 'mass', 'master', 'match', 'material', 'math', 'matrix', 'matter', 'maximum', 'maze', 'meadow', 'mean', 'measure', 'meat', 'mechanic', 'medal', 'media', 'melody', 'melt', 'member', 'memory', 'mention', 'menu', 'mercy', 'merge', 'merit', 'merry', 'mesh', 'message', 'metal', 'method', 'middle', 'midnight', 'milk', 'million', 'mimic', 'mind', 'minimum', 'minor', 'minute', 'miracle', 'mirror', 'misery', 'miss', 'mistake', 'mix', 'mixed', 'mixture', 'mobile', 'model', 'modify', 'mom', 'moment', 'monitor', 'monkey', 'monster', 'month', 'moon', 'moral', 'more', 'morning', 'mosquito', 'mother', 'motion', 'motor', 'mountain', 'mouse', 'move', 'movie', 'much', 'muffin', 'mule', 'multiply', 'muscle', 'museum', 'mushroom', 'music', 'must', 'mutual', 'myself', 'mystery', 'myth', 'naive', 'name', 'napkin', 'narrow', 'nasty', 'nation', 'nature', 'near', 'neck', 'need', 'negative', 'neglect', 'neither', 'nephew', 'nerve', 'nest', 'net', 'network', 'neutral', 'never', 'news', 'next', 'nice', 'night', 'noble', 'noise', 'nominee', 'noodle', 'normal', 'north', 'nose', 'notable', 'note', 'nothing', 'notice', 'novel', 'now', 'nuclear', 'number', 'nurse', 'nut', 'oak', 'obey', 'object', 'oblige', 'obscure', 'observe', 'obtain', 'obvious', 'occur', 'ocean', 'october', 'odor', 'off', 'offer', 'office', 'often', 'oil', 'okay', 'old', 'olive', 'olympic', 'omit', 'once', 'one', 'onion', 'online', 'only', 'open', 'opera', 'opinion', 'oppose', 'option', 'orange', 'orbit', 'orchard', 'order', 'ordinary', 'organ', 'orient', 'original', 'orphan', 'ostrich', 'other', 'outdoor', 'outer', 'output', 'outside', 'oval', 'oven', 'over', 'own', 'owner', 'oxygen', 'oyster', 'ozone', 'pact', 'paddle', 'page', 'pair', 'palace', 'palm', 'panda', 'panel', 'panic', 'panther', 'paper', 'parade', 'parent', 'park', 'parrot', 'party', 'pass', 'patch', 'path', 'patient', 'patrol', 'pattern', 'pause', 'pave', 'payment', 'peace', 'peanut', 'pear', 'peasant', 'pelican', 'pen', 'penalty', 'pencil', 'people', 'pepper', 'perfect', 'permit', 'person', 'pet', 'phone', 'photo', 'phrase', 'physical', 'piano', 'picnic', 'picture', 'piece', 'pig', 'pigeon', 'pill', 'pilot', 'pink', 'pioneer', 'pipe', 'pistol', 'pitch', 'pizza', 'place', 'planet', 'plastic', 'plate', 'play', 'please', 'pledge', 'pluck', 'plug', 'plunge', 'poem', 'poet', 'point', 'polar', 'pole', 'police', 'pond', 'pony', 'pool', 'popular', 'portion', 'position', 'possible', 'post', 'potato', 'pottery', 'poverty', 'powder', 'power', 'practice', 'praise', 'predict', 'prefer', 'prepare', 'present', 'pretty', 'prevent', 'price', 'pride', 'primary', 'print', 'priority', 'prison', 'private', 'prize', 'problem', 'process', 'produce', 'profit', 'program', 'project', 'promote', 'proof', 'property', 'prosper', 'protect', 'proud', 'provide', 'public', 'pudding', 'pull', 'pulp', 'pulse', 'pumpkin', 'punch', 'pupil', 'puppy', 'purchase', 'purity', 'purpose', 'purse', 'push', 'put', 'puzzle', 'pyramid', 'quality', 'quantum', 'quarter', 'question', 'quick', 'quit', 'quiz', 'quote', 'rabbit', 'raccoon', 'race', 'rack', 'radar', 'radio', 'rail', 'rain', 'raise', 'rally', 'ramp', 'ranch', 'random', 'range', 'rapid', 'rare', 'rate', 'rather', 'raven', 'raw', 'razor', 'ready', 'real', 'reason', 'rebel', 'rebuild', 'recall', 'receive', 'recipe', 'record', 'recycle', 'reduce', 'reflect', 'reform', 'refuse', 'region', 'regret', 'regular', 'reject', 'relax', 'release', 'relief', 'rely', 'remain', 'remember', 'remind', 'remove', 'render', 'renew', 'rent', 'reopen', 'repair', 'repeat', 'replace', 'report', 'require', 'rescue', 'resemble', 'resist', 'resource', 'response', 'result', 'retire', 'retreat', 'return', 'reunion', 'reveal', 'review', 'reward', 'rhythm', 'rib', 'ribbon', 'rice', 'rich', 'ride', 'ridge', 'rifle', 'right', 'rigid', 'ring', 'riot', 'ripple', 'risk', 'ritual', 'rival', 'river', 'road', 'roast', 'robot', 'robust', 'rocket', 'romance', 'roof', 'rookie', 'room', 'rose', 'rotate', 'rough', 'round', 'route', 'royal', 'rubber', 'rude', 'rug', 'rule', 'run', 'runway', 'rural', 'sad', 'saddle', 'sadness', 'safe', 'sail', 'salad', 'salmon', 'salon', 'salt', 'salute', 'same', 'sample', 'sand', 'satisfy', 'satoshi', 'sauce', 'sausage', 'save', 'say', 'scale', 'scan', 'scare', 'scatter', 'scene', 'scheme', 'school', 'science', 'scissors', 'scorpion', 'scout', 'scrap', 'screen', 'script', 'scrub', 'sea', 'search', 'season', 'seat', 'second', 'secret', 'section', 'security', 'seed', 'seek', 'segment', 'select', 'sell', 'seminar', 'senior', 'sense', 'sentence', 'series', 'service', 'session', 'settle', 'setup', 'seven', 'shadow', 'shaft', 'shallow', 'share', 'shed', 'shell', 'sheriff', 'shield', 'shift', 'shine', 'ship', 'shiver', 'shock', 'shoe', 'shoot', 'shop', 'short', 'shoulder', 'shove', 'shrimp', 'shrug', 'shuffle', 'shy', 'sibling', 'sick', 'side', 'siege', 'sight', 'sign', 'silent', 'silk', 'silly', 'silver', 'similar', 'simple', 'since', 'sing', 'siren', 'sister', 'situate', 'six', 'size', 'skate', 'sketch', 'ski', 'skill', 'skin', 'skirt', 'skull', 'slab', 'slam', 'sleep', 'slender', 'slice', 'slide', 'slight', 'slim', 'slogan', 'slot', 'slow', 'slush', 'small', 'smart', 'smile', 'smoke', 'smooth', 'snack', 'snake', 'snap', 'sniff', 'snow', 'soap', 'soccer', 'social', 'sock', 'soda', 'soft', 'solar', 'soldier', 'solid', 'solution', 'solve', 'someone', 'song', 'soon', 'sorry', 'sort', 'soul', 'sound', 'soup', 'source', 'south', 'space', 'spare', 'spatial', 'spawn', 'speak', 'special', 'speed', 'spell', 'spend', 'sphere', 'spice', 'spider', 'spike', 'spin', 'spirit', 'split', 'spoil', 'sponsor', 'spoon', 'sport', 'spot', 'spray', 'spread', 'spring', 'spy', 'square', 'squeeze', 'squirrel', 'stable', 'stadium', 'staff', 'stage', 'stairs', 'stamp', 'stand', 'start', 'state', 'stay', 'steak', 'steel', 'stem', 'step', 'stereo', 'stick', 'still', 'sting', 'stock', 'stomach', 'stone', 'stool', 'story', 'stove', 'strategy', 'street', 'strike', 'strong', 'struggle', 'student', 'stuff', 'stumble', 'style', 'subject', 'submit', 'subway', 'success', 'such', 'sudden', 'suffer', 'sugar', 'suggest', 'suit', 'summer', 'sun', 'sunny', 'sunset', 'super', 'supply', 'supreme', 'sure', 'surface', 'surge', 'surprise', 'surround', 'survey', 'suspect', 'sustain', 'swallow', 'swamp', 'swap', 'swarm', 'swear', 'sweet', 'swift', 'swim', 'swing', 'switch', 'sword', 'symbol', 'symptom', 'syrup', 'system', 'table', 'tackle', 'tag', 'tail', 'talent', 'talk', 'tank', 'tape', 'target', 'task', 'taste', 'tattoo', 'taxi', 'teach', 'team', 'tell', 'ten', 'tenant', 'tennis', 'tent', 'term', 'test', 'text', 'thank', 'that', 'theme', 'then', 'theory', 'there', 'they', 'thing', 'this', 'thought', 'three', 'thrive', 'throw', 'thumb', 'thunder', 'ticket', 'tide', 'tiger', 'tilt', 'timber', 'time', 'tiny', 'tip', 'tired', 'tissue', 'title', 'toast', 'tobacco', 'today', 'toddler', 'toe', 'together', 'toilet', 'token', 'tomato', 'tomorrow', 'tone', 'tongue', 'tonight', 'tool', 'tooth', 'top', 'topic', 'topple', 'torch', 'tornado', 'tortoise', 'toss', 'total', 'tourist', 'toward', 'tower', 'town', 'toy', 'track', 'trade', 'traffic', 'tragic', 'train', 'transfer', 'trap', 'trash', 'travel', 'tray', 'treat', 'tree', 'trend', 'trial', 'tribe', 'trick', 'trigger', 'trim', 'trip', 'trophy', 'trouble', 'truck', 'true', 'truly', 'trumpet', 'trust', 'truth', 'try', 'tube', 'tuition', 'tumble', 'tuna', 'tunnel', 'turkey', 'turn', 'turtle', 'twelve', 'twenty', 'twice', 'twin', 'twist', 'two', 'type', 'typical', 'ugly', 'umbrella', 'unable', 'unaware', 'uncle', 'uncover', 'under', 'undo', 'unfair', 'unfold', 'unhappy', 'uniform', 'unique', 'unit', 'universe', 'unknown', 'unlock', 'until', 'unusual', 'unveil', 'update', 'upgrade', 'uphold', 'upon', 'upper', 'upset', 'urban', 'urge', 'usage', 'use', 'used', 'useful', 'useless', 'usual', 'utility', 'vacant', 'vacuum', 'vague', 'valid', 'valley', 'valve', 'van', 'vanish', 'vapor', 'various', 'vast', 'vault', 'vehicle', 'velvet', 'vendor', 'venture', 'venue', 'verb', 'verify', 'version', 'very', 'vessel', 'veteran', 'viable', 'vibrant', 'vicious', 'victory', 'video', 'view', 'village', 'vintage', 'violin', 'virtual', 'virus', 'visa', 'visit', 'visual', 'vital', 'vivid', 'vocal', 'voice', 'void', 'volcano', 'volume', 'vote', 'voyage', 'wage', 'wagon', 'wait', 'walk', 'wall', 'walnut', 'want', 'warfare', 'warm', 'warrior', 'wash', 'wasp', 'waste', 'water', 'wave', 'way', 'wealth', 'weapon', 'wear', 'weasel', 'weather', 'web', 'wedding', 'weekend', 'weird', 'welcome', 'west', 'wet', 'whale', 'what', 'wheat', 'wheel', 'when', 'where', 'whip', 'whisper', 'wide', 'width', 'wife', 'wild', 'will', 'win', 'window', 'wine', 'wing', 'wink', 'winner', 'winter', 'wire', 'wisdom', 'wise', 'wish', 'witness', 'wolf', 'woman', 'wonder', 'wood', 'wool', 'word', 'work', 'world', 'worry', 'worth', 'wrap', 'wreck', 'wrestle', 'wrist', 'write', 'wrong', 'yard', 'year', 'yellow', 'you', 'young', 'youth', 'zebra', 'zero', 'zone', 'zoo'];\r\nMnemonicUtils.DEFAULT_WORDLIST = MnemonicUtils.ENGLISH_WORDLIST;\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nMnemonicUtils.MnemonicType = {\r\n UNKNOWN: -1,\r\n LEGACY: 0,\r\n BIP39: 1,\r\n};\r\n\r\nObject.freeze(MnemonicUtils);\r\n\r\nClass.register(MnemonicUtils);\r\n\r\n/*\r\nbitcoinjs/bip39 LICENSE\r\nCopyright (c) 2014, Wei Lu <luwei.here@gmail.com> and Daniel Cousens <email@dcousens.com>\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted, provided that the above\r\ncopyright notice and this permission notice appear in all copies.\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\r\nWITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\r\nMERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\r\nANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\r\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\r\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\r\nOR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\r\n*/\r\n","class StringUtils {\r\n /**\r\n * @param {string} str\r\n * @returns {boolean}\r\n */\r\n static isMultibyte(str) {\r\n return /[\\uD800-\\uDFFF]/.test(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {boolean}\r\n */\r\n static isHex(str) {\r\n return /^[0-9A-Fa-f]*$/.test(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @param {number} [length]\r\n * @returns {boolean}\r\n */\r\n static isHexBytes(str, length) {\r\n if (!StringUtils.isHex(str)) return false;\r\n if (str.length % 2 !== 0) return false;\r\n if (typeof length === 'number' && str.length / 2 !== length) return false;\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {string} str1\r\n * @param {string} str2\r\n * @returns {string}\r\n */\r\n static commonPrefix(str1, str2) {\r\n let i = 0;\r\n for (; i < str1.length; ++i) {\r\n if (str1[i] !== str2[i]) break;\r\n }\r\n return str1.substr(0, i);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @param {string} padString\r\n * @param {number} length\r\n * @return {string}\r\n */\r\n static lpad(str, padString, length) {\r\n while (str.length < length) str = padString + str;\r\n return str;\r\n }\r\n\r\n}\r\nClass.register(StringUtils);\r\n","class Policy {\r\n /**\r\n * Convert Krypton decimal to Number of Satoshis.\r\n * @param {BigNumber|number|string} coins Krypton count in decimal\r\n * @return {BigNumber} Number of Satoshis\r\n */\r\n static coinsToSatoshis(coins) {\r\n return new BigNumber(coins).times(Policy.SATOSHIS_PER_COIN).integerValue();\r\n }\r\n\r\n /**\r\n * Convert Number of Satoshis to Krypton decimal.\r\n * @param {BigNumber|number|string} satoshis Number of Satoshis.\r\n * @return {BigNumber} Krypton count in decimal.\r\n */\r\n static satoshisToCoins(satoshis) {\r\n return new BigNumber(satoshis).div(Policy.SATOSHIS_PER_COIN);\r\n }\r\n\r\n /**\r\n * Miner reward per block.\r\n * @param {number} blockHeight\r\n * @return {BigNumber}\r\n */\r\n static blockRewardAt(blockHeight) {\r\n if (blockHeight <= 0) return new BigNumber(0);\r\n const halving = Math.min(Math.floor((blockHeight - 1) / Policy.HALVING_INTERVAL), Policy.HALVING_TARGET_MAX - 1);\r\n return new BigNumber(Policy.INITIAL_BLOCK_REWARD).idiv(Math.pow(2, halving));\r\n }\r\n\r\n /**\r\n * targeted block time of block.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static blockTime(blockHeight) {\r\n if (blockHeight <= Policy.BLOCK_TIME_MILESTONE) return Policy.INITIAL_BLOCK_TIME;\r\n if (blockHeight > Policy.HALVING_INTERVAL * Policy.HALVING_TARGET_MAX) return Policy.INITIAL_BLOCK_TIME;\r\n\r\n return Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - Math.floor((blockHeight - 1) / Policy.HALVING_INTERVAL));\r\n }\r\n\r\n /**\r\n * targeted time for block height.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static targetedTime(blockHeight) {\r\n if (blockHeight <= Policy.BLOCK_TIME_MILESTONE) return (blockHeight - 1) * Policy.INITIAL_BLOCK_TIME;\r\n\r\n const initial = Policy.BLOCK_TIME_MILESTONE * Policy.INITIAL_BLOCK_TIME;\r\n const secondBlockTime = Policy.BLOCK_TIME_MULTIPLE * Policy.HALVING_TARGET_MAX;\r\n if (blockHeight <= Policy.HALVING_INTERVAL) {\r\n return initial + (blockHeight - Policy.BLOCK_TIME_MILESTONE - 1) * secondBlockTime;\r\n }\r\n\r\n // first range\r\n let target = initial + (Policy.HALVING_INTERVAL - Policy.BLOCK_TIME_MILESTONE) * secondBlockTime;\r\n // from second range\r\n let height = blockHeight - Policy.HALVING_INTERVAL;\r\n let count = 1;\r\n // calculate for each range\r\n while (height > Policy.HALVING_INTERVAL && count < Policy.HALVING_TARGET_MAX) {\r\n target += Policy.HALVING_INTERVAL * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - count);\r\n height -= Policy.HALVING_INTERVAL;\r\n count += 1;\r\n }\r\n // last\r\n if (count >= Policy.HALVING_TARGET_MAX) {\r\n target += (height - 1) * Policy.INITIAL_BLOCK_TIME;\r\n } else {\r\n target += (height - 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - count);\r\n }\r\n\r\n return target;\r\n }\r\n\r\n /**\r\n * targeted time of block range.\r\n * @param {number} begin\r\n * @param {number} end\r\n * @return {number}\r\n */\r\n static targetedTimeBlockRange(begin, end) {\r\n const beginBlock = begin > 1 ? begin : 1;\r\n const endBlock = end > 1 ? end : 1;\r\n if (beginBlock >= endBlock) return 0;\r\n\r\n const blockMilestoneMax = Policy.HALVING_INTERVAL * Policy.HALVING_TARGET_MAX;\r\n let range = endBlock - beginBlock;\r\n if (endBlock <= Policy.BLOCK_TIME_MILESTONE || beginBlock > blockMilestoneMax) {\r\n return range * Policy.INITIAL_BLOCK_TIME;\r\n }\r\n \r\n const secondBlockTime = Policy.BLOCK_TIME_MULTIPLE * Policy.HALVING_TARGET_MAX;\r\n if (endBlock <= Policy.HALVING_INTERVAL) {\r\n if (beginBlock <= Policy.BLOCK_TIME_MILESTONE) {\r\n return (Policy.BLOCK_TIME_MILESTONE - beginBlock + 1) * Policy.INITIAL_BLOCK_TIME + (endBlock - Policy.BLOCK_TIME_MILESTONE - 1) * secondBlockTime;\r\n }\r\n return range * secondBlockTime;\r\n }\r\n\r\n const beginRangeIndex = Math.floor((beginBlock - 1) / Policy.HALVING_INTERVAL);\r\n let endRangeIndex = Math.floor((endBlock - 1) / Policy.HALVING_INTERVAL);\r\n // in a range\r\n if (beginRangeIndex === endRangeIndex) {\r\n return range * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - beginRangeIndex);\r\n }\r\n\r\n let beginBlocksTime;\r\n let middleBlocksTime = 0;\r\n let endBlocksTime;\r\n if (beginBlock <= Policy.BLOCK_TIME_MILESTONE) {\r\n beginBlocksTime = (Policy.BLOCK_TIME_MILESTONE - beginBlock + 1) * Policy.INITIAL_BLOCK_TIME + (Policy.HALVING_INTERVAL - Policy.BLOCK_TIME_MILESTONE) * secondBlockTime;\r\n } else {\r\n const beginBlockMilestone = (beginRangeIndex + 1) * Policy.HALVING_INTERVAL;\r\n beginBlocksTime = (beginBlockMilestone - beginBlock + 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - beginRangeIndex);\r\n }\r\n if (endBlock > blockMilestoneMax) {\r\n endRangeIndex = Policy.HALVING_TARGET_MAX;\r\n endBlocksTime = (endBlock - blockMilestoneMax - 1) * Policy.INITIAL_BLOCK_TIME;\r\n } else {\r\n const endBlockMilestone = endRangeIndex * Policy.HALVING_INTERVAL;\r\n endBlocksTime = (endBlock - endBlockMilestone - 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - endRangeIndex);\r\n }\r\n for (let i = beginRangeIndex + 1; i < endRangeIndex; i++) {\r\n middleBlocksTime += Policy.HALVING_INTERVAL * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - i);\r\n }\r\n return beginBlocksTime + middleBlocksTime + endBlocksTime;\r\n }\r\n\r\n /**\r\n * tx fee at block.\r\n * @param {number} blockHeight\r\n * @return {BigNumber}\r\n */\r\n static txFee(blockHeight) {\r\n if (blockHeight <= 1) return new BigNumber(0);\r\n const changing = Math.floor((blockHeight - 1) / Policy.TX_FEE_CHANGING_INTERVAL);\r\n if (changing < Policy.TX_FEE_CHANGING_TOTAL_NUMBER) {\r\n return new BigNumber(Policy.INITIAL_TX_FEE).div(Math.pow(10, changing));\r\n }\r\n return new BigNumber(1);\r\n }\r\n\r\n /**\r\n * block size.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static blockSize(blockHeight) {\r\n if (blockHeight < Policy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE) return Policy.INITIAL_BLOCK_SIZE;\r\n return Policy.BASE_BLOCK_SIZE + Policy.BLOCK_SIZE_FACTOR * Math.floor(blockHeight / Policy.BLOCK_SIZE_CHANGING_INTERVAL);\r\n }\r\n\r\n /**\r\n * difficulty block window\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static difficultyBlockWindow(blockHeight) {\r\n if (blockHeight >= Policy.SECOND_FORKING_FOR_BLOCK_DIFFICULTY\r\n || blockHeight < Policy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE) return Policy.DIFFICULTY_BLOCK_WINDOW;\r\n \r\n const time = Policy.blockTime(blockHeight);\r\n return Math.floor(360 / time);\r\n }\r\n}\r\n\r\n/**\r\n * Targeted block time in seconds.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_TIME = 3;\r\n\r\n/**\r\n * Multiple block time argument.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TIME_MULTIPLE = 3;\r\n\r\n/**\r\n * Milestone for the first time that block time changed.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TIME_MILESTONE = 1100000;\r\n\r\n/**\r\n * Initial block size in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_SIZE = 1e5; // 100 kb\r\n\r\n/**\r\n * base block size in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BASE_BLOCK_SIZE = 2100000; // 2.1 Mb\r\n\r\n/**\r\n * block size factor in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_SIZE_FACTOR = 2100; // 2.1 kb\r\n\r\n/**\r\n * Block size will be change every 2.1M blocks.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_SIZE_CHANGING_INTERVAL = 2100000;\r\n\r\n/**\r\n * The highest (easiest) block PoW target.\r\n * @type {BigNumber}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TARGET_MAX = new BigNumber(2).pow(240);\r\n\r\n/**\r\n * Number of blocks we take into account to calculate next difficulty.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DIFFICULTY_BLOCK_WINDOW = 120;\r\n\r\n/**\r\n * Block number that we apply some new settings about block difficulty, block size.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE = 1124816;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min/max.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 2;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted max.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NEW_DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 1.3;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NEW_DIFFICULTY_MIN_ADJUSTMENT_FACTOR = 0.7;\r\n\r\n/**\r\n * Block number that we apply some new settings about block difficulty (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_FORKING_FOR_BLOCK_DIFFICULTY = 1132333;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted max (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 1.5;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_DIFFICULTY_MIN_ADJUSTMENT_FACTOR = 0.5;\r\n\r\n/**\r\n * Number of blocks a transaction is valid.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TRANSACTION_VALIDITY_WINDOW = 120;\r\n\r\n\r\n/* Supply & Emission Parameters */\r\n\r\n/**\r\n * Number of Satoshis per Krypton.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SATOSHIS_PER_COIN = 1e11;\r\n\r\n/**\r\n * Initial supply before genesis block in satoshis.\r\n * @type {number}\r\n * @constant\r\n */\r\n\r\nPolicy.INITIAL_SUPPLY = 0;\r\n\r\n/**\r\n * block reward in satoshis\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_REWARD = 5e11;\r\n\r\n/**\r\n * in this time the block reward should not be halved anymore\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.HALVING_TARGET_MAX = 21;\r\n\r\n/**\r\n * halving the block reward each 2.100.000 blocks\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.HALVING_INTERVAL = 2100000;\r\n\r\n/* Security parameters */\r\n\r\n/**\r\n * NIPoPoW Security parameter M\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.M = 240;\r\n\r\n/**\r\n * NIPoPoW Security parameter K\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.K = 120;\r\n\r\n/**\r\n * NIPoPoW Security parameter DELTA\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DELTA = 0.15;\r\n\r\n/**\r\n * Number of blocks the light client downloads to verify the AccountsTree construction.\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NUM_BLOCKS_VERIFICATION = 250;\r\n\r\n\r\n/* Snapshot Parameters */\r\n\r\n/**\r\n * Maximum number of snapshots.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NUM_SNAPSHOTS_MAX = 20;\r\n\r\n/* Tx */\r\n\r\n/**\r\n * Initial tx fee in Satoshi\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_TX_FEE = 1e6; // 1M\r\n\r\n/**\r\n * changine tx fee each 6300000 blocks\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TX_FEE_CHANGING_INTERVAL = 6300000;\r\n\r\n/**\r\n * Total number of changing tx fee\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TX_FEE_CHANGING_TOTAL_NUMBER = 6;\r\n\r\nClass.register(Policy);\r\n","/**\r\n * @abstract\r\n */\r\nclass Serializable {\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Serializable && BufferUtils.equals(this.serialize(), o.serialize());\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {number} negative if this is smaller than o, positive if this is larger than o, zero if equal.\r\n */\r\n compare(o) {\r\n return BufferUtils.compare(this.serialize(), o.serialize());\r\n }\r\n\r\n hashCode() {\r\n return this.toBase64();\r\n }\r\n\r\n /**\r\n * @abstract\r\n * @param {SerialBuffer} [buf]\r\n */\r\n serialize(buf) {}\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toString() {\r\n return this.toBase64();\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBase64() {\r\n return BufferUtils.toBase64(this.serialize());\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toHex() {\r\n return BufferUtils.toHex(this.serialize());\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBase58() {\r\n return BufferUtils.toBase58(this.serialize());\r\n }\r\n\r\n /**\r\n * @param {number}\r\n * @return {string}\r\n */\r\n toBase58Check(prefix = 0x80, suffix) {\r\n return BufferUtils.toBase58Check(this.serialize(), prefix, suffix);\r\n }\r\n}\r\n\r\nClass.register(Serializable);\r\n","class Hash extends Serializable {\r\n /**\r\n * @param {?Uint8Array} arg\r\n * @param {Hash.Algorithm} [algorithm]\r\n * @private\r\n */\r\n constructor(arg, algorithm = Hash.Algorithm.BLAKE2B) {\r\n if (arg === null) {\r\n arg = new Uint8Array(Hash.getSize(algorithm));\r\n } else {\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Hash.getSize(algorithm)) throw new Error('Primitive: Invalid length');\r\n }\r\n super();\r\n this._obj = arg;\r\n /** @type {Hash.Algorithm} */\r\n this._algorithm = algorithm;\r\n }\r\n\r\n /**\r\n * @deprecated\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static light(arr) {\r\n return Hash.blake2b(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static blake2b(arr) {\r\n return new Hash(Hash.computeBlake2b(arr), Hash.Algorithm.BLAKE2B);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @deprecated\r\n * @returns {Promise.<Hash>}\r\n */\r\n static hard(arr) {\r\n return Hash.argon2d(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Promise.<Hash>}\r\n */\r\n static async argon2d(arr) {\r\n return new Hash(await (await CryptoWorker.getInstanceAsync()).computeArgon2d(arr), Hash.Algorithm.ARGON2D);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static sha256(arr) {\r\n return new Hash(Hash.computeSha256(arr), Hash.Algorithm.SHA256);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static sha512(arr) {\r\n return new Hash(Hash.computeSha512(arr), Hash.Algorithm.SHA512);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static ripemd160(arr) {\r\n return new Hash(Hash.computeRipemd160(arr), Hash.Algorithm.RIPEMD160);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static doubleHash(arr) {\r\n return Hash.ripemd160(Hash.computeSha256(arr));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static keccak256(arr) {\r\n return new Hash(Hash.computeKeccak256(arr), Hash.Algorithm.KECCAK256);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @param {Hash.Algorithm} algorithm\r\n * @returns {Hash}\r\n */\r\n static compute(arr, algorithm) {\r\n // !! The algorithms supported by this function are the allowed hash algorithms for HTLCs !!\r\n switch (algorithm) {\r\n case Hash.Algorithm.BLAKE2B: return Hash.blake2b(arr);\r\n case Hash.Algorithm.SHA256: return Hash.sha256(arr);\r\n // Hash.Algorithm.SHA512 postponed until hard-fork\r\n // Hash.Algorithm.ARGON2 intentionally omitted\r\n default: throw new Error('Invalid hash algorithm');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Hash.Algorithm} [algorithm]\r\n * @returns {Hash}\r\n */\r\n static unserialize(buf, algorithm = Hash.Algorithm.BLAKE2B) {\r\n return new Hash(buf.read(Hash.getSize(algorithm)), algorithm);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @returns {Uint8Array}\r\n */\r\n subarray(begin, end) {\r\n return this._obj.subarray(begin, end);\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Hash.SIZE.get(this._algorithm);\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get array() {\r\n return this._obj;\r\n }\r\n\r\n /** @type {Hash.Algorithm} */\r\n get algorithm() {\r\n return this._algorithm;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Hash && o._algorithm === this._algorithm && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Hash|Uint8Array|string} hash\r\n * @param {Hash.Algorithm} algorithm\r\n * @return {Hash}\r\n */\r\n static fromAny(hash, algorithm = Hash.Algorithm.BLAKE2B) {\r\n if (hash instanceof Hash) return hash;\r\n try {\r\n return new Hash(BufferUtils.fromAny(hash, Hash.SIZE.get(algorithm)), algorithm);\r\n } catch (e) {\r\n throw new Error('Invalid hash format');\r\n }\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n toPlain() {\r\n return this.toHex();\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @returns {Hash}\r\n */\r\n static fromBase64(base64) {\r\n return new Hash(BufferUtils.fromBase64(base64));\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @returns {Hash}\r\n */\r\n static fromHex(hex) {\r\n return new Hash(BufferUtils.fromHex(hex));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Hash}\r\n */\r\n static fromPlain(str) {\r\n return Hash.fromString(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Hash}\r\n */\r\n static fromString(str) {\r\n try {\r\n return Hash.fromHex(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Hash.fromBase64(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n throw new Error('Invalid hash format');\r\n }\r\n\r\n /**\r\n * @param {Hash} o\r\n * @returns {boolean}\r\n */\r\n static isHash(o) {\r\n return o instanceof Hash;\r\n }\r\n\r\n /**\r\n * @param {Hash.Algorithm} algorithm\r\n * @returns {number}\r\n */\r\n static getSize(algorithm) {\r\n const size = Hash.SIZE.get(algorithm);\r\n if (typeof size !== 'number') throw new Error('Invalid hash algorithm');\r\n return size;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeBlake2b(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.BLAKE2B));\r\n NodeNative.node_blake2(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.BLAKE2B);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n const res = Module._krypton_blake2(wasmOut, wasmIn, input.length);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeSha256(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA256));\r\n NodeNative.node_sha256(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._krypton_sha256(wasmOut, wasmIn, input.length);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeSha512(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA512));\r\n NodeNative.node_sha512(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA512);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._krypton_sha512(wasmOut, wasmIn, input.length);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeRipemd160(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.RIPEMD160));\r\n NodeNative.node_ripemd160(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.RIPEMD160);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._ripemd160(wasmIn, input.length, wasmOut);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeKeccak256(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.KECCAK256));\r\n NodeNative.node_keccak256(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.KECCAK256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._keccak256(wasmIn, input.length, wasmOut);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nHash.Algorithm = {\r\n BLAKE2B: 1,\r\n ARGON2D: 2,\r\n SHA256: 3,\r\n SHA512: 4,\r\n RIPEMD160: 5,\r\n KECCAK256: 6\r\n};\r\n/**\r\n * @param {Hash.Algorithm} hashAlgorithm\r\n * @return {string}\r\n */\r\nHash.Algorithm.toString = function(hashAlgorithm) {\r\n switch (hashAlgorithm) {\r\n case Hash.Algorithm.BLAKE2B: return 'blake2b';\r\n case Hash.Algorithm.ARGON2D: return 'argon2d';\r\n case Hash.Algorithm.SHA256: return 'sha256';\r\n case Hash.Algorithm.SHA512: return 'sha512';\r\n case Hash.Algorithm.RIPEMD160: return 'ripemd160';\r\n case Hash.Algorithm.KECCAK256: return 'keccak256';\r\n }\r\n throw new Error('Invalid hash algorithm');\r\n};\r\n\r\n/**\r\n * @param {Hash.Algorithm|string} algorithm\r\n * @returns {Hash.Algorithm}\r\n */\r\nHash.Algorithm.fromAny = function (algorithm) {\r\n if (typeof algorithm === 'number') return algorithm;\r\n switch (algorithm) {\r\n case 'blake2b': return Hash.Algorithm.BLAKE2B;\r\n case 'argon2d': return Hash.Algorithm.ARGON2D;\r\n case 'sha256': return Hash.Algorithm.SHA256;\r\n case 'sha512': return Hash.Algorithm.SHA512;\r\n case 'ripemd160': return Hash.Algorithm.RIPEMD160;\r\n case 'keccak256': return Hash.Algorithm.KECCAK256;\r\n }\r\n throw new Error('Invalid hash algorithm');\r\n};\r\n\r\n/**\r\n * @type {Map<Hash.Algorithm, number>}\r\n */\r\nHash.SIZE = new Map();\r\nHash.SIZE.set(Hash.Algorithm.BLAKE2B, 32);\r\nHash.SIZE.set(Hash.Algorithm.ARGON2D, 32);\r\nHash.SIZE.set(Hash.Algorithm.SHA256, 32);\r\nHash.SIZE.set(Hash.Algorithm.SHA512, 64);\r\nHash.SIZE.set(Hash.Algorithm.RIPEMD160, 20);\r\nHash.SIZE.set(Hash.Algorithm.KECCAK256, 32);\r\n\r\nHash.NULL = new Hash(new Uint8Array(32));\r\nClass.register(Hash);\r\n","class Secret extends Serializable {\r\n /**\r\n * @param {Secret.Type} type\r\n * @param {number} purposeId\r\n */\r\n constructor(type, purposeId) {\r\n super();\r\n this._type = type;\r\n this._purposeId = purposeId;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Uint8Array} key\r\n * @return {Promise.<PrivateKey|Entropy>}\r\n */\r\n static fromEncrypted(buf, key) {\r\n const version = buf.readUint8();\r\n\r\n const roundsLog = buf.readUint8();\r\n if (roundsLog > 32) throw new Error('Rounds out-of-bounds');\r\n const rounds = Math.pow(2, roundsLog);\r\n\r\n switch (version) {\r\n case 1:\r\n return Secret._decryptV1(buf, key, rounds);\r\n case 2:\r\n return Secret._decryptV2(buf, key, rounds);\r\n case 3:\r\n return Secret._decryptV3(buf, key, rounds);\r\n default:\r\n throw new Error('Unsupported version');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Uint8Array} key\r\n * @param {number} rounds\r\n * @returns {Promise.<PrivateKey>}\r\n * @private\r\n */\r\n static async _decryptV1(buf, key, rounds) {\r\n const ciphertext = buf.read(Secret.SIZE);\r\n const salt = buf.read(Secret.ENCRYPTION_SALT_SIZE);\r\n const check = buf.read(Secret.ENCRYPTION_CHECKSUM_SIZE);\r\n const plaintext = await CryptoUtils.otpKdfLegacy(ciphertext, key, salt, rounds);\r\n\r\n const privateKey = new PrivateKey(plaintext);\r\n const publicKey = PublicKey.derive(privateKey);\r\n const checksum = publicKey.hash().subarray(0, Secret.ENCRYPTION_CHECKSUM_SIZE);\r\n if (!BufferUtils.equals(check, checksum)) {\r\n throw new Error('Invalid key');\r\n }\r\n\r\n return privateKey;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Uint8Array} key\r\n * @param {number} rounds\r\n * @returns {Promise.<PrivateKey>}\r\n * @private\r\n */\r\n static async _decryptV2(buf, key, rounds) {\r\n const ciphertext = buf.read(Secret.SIZE);\r\n const salt = buf.read(Secret.ENCRYPTION_SALT_SIZE);\r\n const check = buf.read(Secret.ENCRYPTION_CHECKSUM_SIZE);\r\n const plaintext = await CryptoUtils.otpKdfLegacy(ciphertext, key, salt, rounds);\r\n\r\n const checksum = Hash.computeBlake2b(plaintext).subarray(0, Secret.ENCRYPTION_CHECKSUM_SIZE);\r\n if (!BufferUtils.equals(check, checksum)) {\r\n throw new Error('Invalid key');\r\n }\r\n\r\n return new PrivateKey(plaintext);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Uint8Array} key\r\n * @param {number} rounds\r\n * @returns {Promise.<PrivateKey|Entropy>}\r\n * @private\r\n */\r\n static async _decryptV3(buf, key, rounds) {\r\n const salt = buf.read(Secret.ENCRYPTION_SALT_SIZE);\r\n const ciphertext = buf.read(Secret.ENCRYPTION_CHECKSUM_SIZE_V3 + /*purposeId*/ 4 + Secret.SIZE);\r\n const plaintext = await CryptoUtils.otpKdf(ciphertext, key, salt, rounds);\r\n\r\n const check = plaintext.subarray(0, Secret.ENCRYPTION_CHECKSUM_SIZE_V3);\r\n const payload = plaintext.subarray(Secret.ENCRYPTION_CHECKSUM_SIZE_V3);\r\n const checksum = Hash.computeBlake2b(payload).subarray(0, Secret.ENCRYPTION_CHECKSUM_SIZE_V3);\r\n if (!BufferUtils.equals(check, checksum)) {\r\n throw new Error('Invalid key');\r\n }\r\n\r\n const purposeId = payload[0] << 24 | payload[1] << 16 | payload[2] << 8 | payload[3];\r\n const secret = payload.subarray(4);\r\n switch (purposeId) {\r\n case PrivateKey.PURPOSE_ID:\r\n return new PrivateKey(secret);\r\n case Entropy.PURPOSE_ID:\r\n default:\r\n return new Entropy(secret);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @return {Promise.<SerialBuffer>}\r\n */\r\n async exportEncrypted(key) {\r\n const salt = new Uint8Array(Secret.ENCRYPTION_SALT_SIZE);\r\n CryptoWorker.lib.getRandomValues(salt);\r\n\r\n const data = new SerialBuffer(/*purposeId*/ 4 + Secret.SIZE);\r\n data.writeUint32(this._purposeId);\r\n data.write(this.serialize());\r\n\r\n const checksum = Hash.computeBlake2b(data).subarray(0, Secret.ENCRYPTION_CHECKSUM_SIZE_V3);\r\n const plaintext = new SerialBuffer(checksum.byteLength + data.byteLength);\r\n plaintext.write(checksum);\r\n plaintext.write(data);\r\n const ciphertext = await CryptoUtils.otpKdf(plaintext, key, salt, Secret.ENCRYPTION_KDF_ROUNDS);\r\n\r\n const buf = new SerialBuffer(/*version*/ 1 + /*kdf rounds*/ 1 + salt.byteLength + ciphertext.byteLength);\r\n buf.writeUint8(3); // version\r\n buf.writeUint8(Math.log2(Secret.ENCRYPTION_KDF_ROUNDS));\r\n buf.write(salt);\r\n buf.write(ciphertext);\r\n\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get encryptedSize() {\r\n return /*version*/ 1\r\n + /*kdf rounds*/ 1\r\n + Secret.ENCRYPTION_SALT_SIZE\r\n + Secret.ENCRYPTION_CHECKSUM_SIZE_V3\r\n + /*purposeId*/ 4\r\n + Secret.SIZE;\r\n }\r\n\r\n /** @type {Secret.Type} */\r\n get type() {\r\n return this._type;\r\n }\r\n}\r\n\r\nSecret.Type = {\r\n PRIVATE_KEY: 1,\r\n ENTROPY: 2\r\n};\r\nSecret.SIZE = 32;\r\n\r\nSecret.ENCRYPTION_SALT_SIZE = 16;\r\nSecret.ENCRYPTION_KDF_ROUNDS = 256;\r\nSecret.ENCRYPTION_CHECKSUM_SIZE = 4;\r\nSecret.ENCRYPTION_CHECKSUM_SIZE_V3 = 2;\r\n\r\nClass.register(Secret);\r\n","class PrivateKey extends Secret {\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super(Secret.Type.PRIVATE_KEY, PrivateKey.PURPOSE_ID);\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== PrivateKey.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @return {PrivateKey}\r\n */\r\n static generate() {\r\n const privateKey = new Uint8Array(PrivateKey.SIZE);\r\n CryptoWorker.lib.getRandomValues(privateKey);\r\n return new PrivateKey(privateKey);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {PrivateKey}\r\n */\r\n static unserialize(buf) {\r\n return new PrivateKey(buf.read(PrivateKey.SIZE));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return PrivateKey.SIZE;\r\n }\r\n\r\n /**\r\n * Overwrite this private key with a replacement in-memory\r\n * @param {PrivateKey} privateKey\r\n */\r\n overwrite(privateKey) {\r\n this._obj.set(privateKey._obj);\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof PrivateKey && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} privateKey\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} publicKeysHash\r\n * @returns {Uint8Array}\r\n */\r\n static _privateKeyDelinearize(privateKey, publicKey, publicKeysHash) {\r\n if (privateKey.byteLength !== PrivateKey.SIZE\r\n || publicKey.byteLength !== PublicKey.SIZE\r\n || publicKeysHash.byteLength !== Hash.getSize(Hash.Algorithm.SHA256)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_derive_delinearized_seckey(out, new Uint8Array(publicKeysHash), new Uint8Array(publicKey), new Uint8Array(privateKey));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const wasmInPrivateKey = Module.stackAlloc(privateKey.length);\r\n const wasmInPublicKey = Module.stackAlloc(publicKey.length);\r\n const wasmInPublicKeysHash = Module.stackAlloc(publicKeysHash.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPrivateKey, privateKey.length).set(privateKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKey, publicKey.length).set(publicKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeysHash, publicKeysHash.length).set(publicKeysHash);\r\n Module._secp256k1_derive_delinearized_seckey(wasmOut, wasmInPublicKeysHash, wasmInPublicKey, wasmInPrivateKey);\r\n const delinearizedPrivateKey = new Uint8Array(PrivateKey.SIZE);\r\n delinearizedPrivateKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PrivateKey.SIZE));\r\n return delinearizedPrivateKey;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nPrivateKey.SIZE = Secret.SIZE;\r\nPrivateKey.PURPOSE_ID = 0x42000001;\r\n\r\nClass.register(PrivateKey);\r\n","class PublicKey extends Serializable {\r\n /**\r\n * @param {PublicKey} o\r\n * @returns {PublicKey}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n return new PublicKey(new Uint8Array(o._obj));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== PublicKey.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @return {PublicKey}\r\n */\r\n static derive(privateKey) {\r\n return new PublicKey(PublicKey._publicKeyDerive(privateKey._obj));\r\n }\r\n\r\n /**\r\n * @return {Uint8Array}\r\n */\r\n compress() {\r\n return PublicKey._compressPublicKey(this._obj);\r\n }\r\n\r\n /**\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @return {PublicKey}\r\n */\r\n static sum(publicKeys) {\r\n publicKeys = publicKeys.slice();\r\n publicKeys.sort((a, b) => a.compare(b));\r\n return PublicKey._delinearizeAndAggregatePublicKeys(publicKeys);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {PublicKey}\r\n */\r\n static unserialize(buf) {\r\n return new PublicKey(buf.read(PublicKey.SIZE));\r\n }\r\n\r\n /**\r\n * @param {PublicKey|Uint8Array|string} o\r\n * @return {PublicKey}\r\n */\r\n static fromAny(o) {\r\n if (!o) throw new Error('Invalid public key format');\r\n if (o instanceof PublicKey) return o;\r\n try {\r\n return new PublicKey(BufferUtils.fromAny(o, PublicKey.SIZE));\r\n } catch (e) {\r\n throw new Error('Invalid public key format');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return PublicKey.SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof PublicKey && super.equals(o);\r\n }\r\n\r\n /**\r\n * @return {Hash}\r\n */\r\n hash() {\r\n return Hash.keccak256(this.serialize().slice(1)); // skip the type byte\r\n }\r\n\r\n /**\r\n * @param {PublicKey} o\r\n * @return {number}\r\n */\r\n compare(o) {\r\n return BufferUtils.compare(this._obj, o._obj);\r\n }\r\n\r\n /**\r\n * @return {Address}\r\n */\r\n toAddress() {\r\n return Address.fromHash(this.hash());\r\n }\r\n\r\n /**\r\n * @return {PeerId}\r\n */\r\n toPeerId() {\r\n return new PeerId(this.hash().subarray(0, 16));\r\n }\r\n\r\n /**\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @returns {PublicKey}\r\n */\r\n static _delinearizeAndAggregatePublicKeys(publicKeys) {\r\n const publicKeysObj = publicKeys.map(k => k.serialize());\r\n const publicKeysHash = PublicKey._publicKeysHash(publicKeysObj);\r\n const raw = PublicKey._publicKeysDelinearizeAndAggregate(publicKeysObj, publicKeysHash);\r\n return new PublicKey(raw);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @returns {Uint8Array}\r\n */\r\n static _compressPublicKey(publicKey) {\r\n if (publicKey.byteLength !== PublicKey.SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(PublicKey.COMPRESSED_SIZE);\r\n NodeNative.node_secp256k1_pubkey_compress(out, new Uint8Array(publicKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOut = Module.stackAlloc(PublicKey.COMPRESSED_SIZE);\r\n const pubKeyBufferOut = new Uint8Array(Module.HEAP8.buffer, wasmOut, PublicKey.COMPRESSED_SIZE);\r\n \r\n const wasmIn = Module.stackAlloc(PublicKey.SIZE);\r\n const pubKeyBufferIn = new Uint8Array(Module.HEAP8.buffer, wasmIn, PublicKey.SIZE);\r\n pubKeyBufferIn.set(publicKey);\r\n\r\n Module._secp256k1_pubkey_compress(wasmOut, wasmIn);\r\n const compressed = new Uint8Array(PublicKey.COMPRESSED_SIZE);\r\n compressed.set(pubKeyBufferOut);\r\n return compressed;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} privateKey\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeyDerive(privateKey) {\r\n if (privateKey.byteLength !== PrivateKey.SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_pubkey_create(out, new Uint8Array(privateKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const pubKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmOut, PublicKey.SIZE);\r\n \r\n const wasmIn = Module.stackAlloc(privateKey.length);\r\n const privKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmIn, PrivateKey.SIZE);\r\n privKeyBuffer.set(privateKey);\r\n\r\n Module._secp256k1_pubkey_create(wasmOut, PublicKey.SIZE, wasmIn);\r\n privKeyBuffer.fill(0);\r\n const publicKey = new Uint8Array(PublicKey.SIZE);\r\n publicKey.set(pubKeyBuffer);\r\n return publicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} publicKeys\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeysHash(publicKeys) {\r\n if (publicKeys.some(publicKey => publicKey.byteLength !== PublicKey.SIZE)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const concatenatedPublicKeys = new Uint8Array(publicKeys.length * PublicKey.SIZE);\r\n for (let i = 0; i < publicKeys.length; ++i) {\r\n concatenatedPublicKeys.set(publicKeys[i], i * PublicKey.SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA256));\r\n NodeNative.node_secp256k1_hash_pubkeys(out, concatenatedPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmInPublicKeys = Module.stackAlloc(concatenatedPublicKeys.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeys, concatenatedPublicKeys.length).set(concatenatedPublicKeys);\r\n Module._secp256k1_hash_pubkeys(wasmOut, wasmInPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n const hashedPublicKey = new Uint8Array(hashSize);\r\n hashedPublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hashedPublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} publicKeysHash\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeyDelinearize(publicKey, publicKeysHash) {\r\n if (publicKey.byteLength !== PublicKey.SIZE\r\n || publicKeysHash.byteLength !== Hash.getSize(Hash.Algorithm.SHA256)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_delinearize_pubkey(out, new Uint8Array(publicKeysHash), new Uint8Array(publicKey));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const wasmInPublicKey = Module.stackAlloc(publicKey.length);\r\n const wasmInPublicKeysHash = Module.stackAlloc(publicKeysHash.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKey, publicKey.length).set(publicKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeysHash, publicKeysHash.length).set(publicKeysHash);\r\n Module._secp256k1_delinearize_pubkey(wasmOut, wasmInPublicKeysHash, wasmInPublicKey);\r\n const delinearizedPublicKey = new Uint8Array(PublicKey.SIZE);\r\n delinearizedPublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PublicKey.SIZE));\r\n return delinearizedPublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} publicKeys\r\n * @param {Uint8Array} publicKeysHash\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeysDelinearizeAndAggregate(publicKeys, publicKeysHash) {\r\n if (publicKeys.some(publicKey => publicKey.byteLength !== PublicKey.SIZE)\r\n || publicKeysHash.byteLength !== Hash.getSize(Hash.Algorithm.SHA256)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const concatenatedPublicKeys = new Uint8Array(publicKeys.length * PublicKey.SIZE);\r\n for (let i = 0; i < publicKeys.length; ++i) {\r\n concatenatedPublicKeys.set(publicKeys[i], i * PublicKey.SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_aggregate_delinearized_publkeys(out, new Uint8Array(publicKeysHash), concatenatedPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const wasmInPublicKeys = Module.stackAlloc(concatenatedPublicKeys.length);\r\n const wasmInPublicKeysHash = Module.stackAlloc(publicKeysHash.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeys, concatenatedPublicKeys.length).set(concatenatedPublicKeys);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeysHash, publicKeysHash.length).set(publicKeysHash);\r\n Module._secp256k1_aggregate_delinearized_publkeys(wasmOut, wasmInPublicKeysHash, wasmInPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n const aggregatePublicKey = new Uint8Array(PublicKey.SIZE);\r\n aggregatePublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PublicKey.SIZE));\r\n return aggregatePublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nPublicKey.COMPRESSED_SIZE = 33;\r\nPublicKey.SIZE = 65;\r\n\r\nClass.register(PublicKey);\r\n","class KeyPair extends Serializable {\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @param {PublicKey} publicKey\r\n * @param {boolean} locked\r\n * @param {Uint8Array} lockSalt\r\n * @private\r\n */\r\n constructor(privateKey, publicKey, locked = false, lockSalt = null) {\r\n if (!(privateKey instanceof Object)) throw new Error('Primitive: Invalid type');\r\n if (!(publicKey instanceof Object)) throw new Error('Primitive: Invalid type');\r\n super();\r\n\r\n /** @type {boolean} */\r\n this._locked = locked;\r\n /** @type {boolean} */\r\n this._lockedInternally = locked;\r\n /** @type {Uint8Array} */\r\n this._lockSalt = lockSalt;\r\n /** @type {PublicKey} */\r\n this._publicKey = publicKey;\r\n /** @type {PrivateKey} */\r\n this._internalPrivateKey = new PrivateKey(privateKey.serialize());\r\n }\r\n\r\n /**\r\n * @return {KeyPair}\r\n */\r\n static generate() {\r\n const privateKey = PrivateKey.generate();\r\n return new KeyPair(privateKey, PublicKey.derive(privateKey));\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @return {KeyPair}\r\n */\r\n static derive(privateKey) {\r\n return new KeyPair(privateKey, PublicKey.derive(privateKey));\r\n }\r\n\r\n /**\r\n * @param {string} hexBuf\r\n * @return {KeyPair}\r\n */\r\n static fromHex(hexBuf) {\r\n return KeyPair.unserialize(BufferUtils.fromHex(hexBuf));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {KeyPair}\r\n */\r\n static unserialize(buf) {\r\n const privateKey = PrivateKey.unserialize(buf);\r\n const publicKey = PublicKey.unserialize(buf);\r\n let locked = false;\r\n let lockSalt = null;\r\n if (buf.readPos < buf.byteLength) {\r\n const extra = buf.readUint8();\r\n if (extra === 1) {\r\n locked = true;\r\n lockSalt = buf.read(32);\r\n }\r\n }\r\n return new KeyPair(privateKey, publicKey, locked, lockSalt);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._privateKey.serialize(buf);\r\n this.publicKey.serialize(buf);\r\n if (this._locked) {\r\n buf.writeUint8(1);\r\n buf.write(this._lockSalt);\r\n } else {\r\n buf.writeUint8(0);\r\n }\r\n return buf;\r\n }\r\n\r\n /**\r\n * The unlocked private key.\r\n * @type {PrivateKey}\r\n */\r\n get privateKey() {\r\n if (this.isLocked) throw new Error('KeyPair is locked');\r\n return this._privateKey;\r\n }\r\n\r\n /**\r\n * The private key in its current state, i.e., depending on this._locked.\r\n * If this._locked, it is the internally locked private key.\r\n * If !this._locked, it is either the internally unlocked private key (if !this._lockedInternally)\r\n * or this._unlockedPrivateKey.\r\n * @type {PrivateKey}\r\n */\r\n get _privateKey() {\r\n return this._unlockedPrivateKey || this._internalPrivateKey;\r\n }\r\n\r\n /** @type {PublicKey} */\r\n get publicKey() {\r\n return this._publicKey || (this._publicKey = new PublicKey(this._obj.publicKey));\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this._privateKey.serializedSize + this.publicKey.serializedSize + (this._locked ? this._lockSalt.byteLength + 1 : 1);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} [lockSalt]\r\n */\r\n async lock(key, lockSalt) {\r\n if (this._locked) throw new Error('KeyPair already locked');\r\n\r\n if (lockSalt) this._lockSalt = lockSalt;\r\n if (!this._lockSalt || this._lockSalt.length === 0) {\r\n this._lockSalt = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(this._lockSalt);\r\n }\r\n\r\n this._internalPrivateKey.overwrite(await this._otpPrivateKey(key));\r\n this._clearUnlockedPrivateKey();\r\n this._locked = true;\r\n this._lockedInternally = true;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n */\r\n async unlock(key) {\r\n if (!this._locked) throw new Error('KeyPair not locked');\r\n\r\n const privateKey = await this._otpPrivateKey(key);\r\n const verifyPub = PublicKey.derive(privateKey);\r\n if (verifyPub.equals(this.publicKey)) {\r\n // Only set this._internalPrivateKey, but keep this._obj locked.\r\n this._unlockedPrivateKey = privateKey;\r\n this._locked = false;\r\n } else {\r\n throw new Error('Invalid key');\r\n }\r\n }\r\n\r\n /**\r\n * Destroy cached unlocked private key if the internal key is in locked state.\r\n */\r\n relock() {\r\n if (this._locked) throw new Error('KeyPair already locked');\r\n if (!this._lockedInternally) throw new Error('KeyPair was never locked');\r\n this._clearUnlockedPrivateKey();\r\n this._locked = true;\r\n }\r\n\r\n _clearUnlockedPrivateKey() {\r\n // If this wallet is not locked internally and unlocked, this method does not have any effect.\r\n if (!this._lockedInternally || this._locked) return;\r\n\r\n // Overwrite cached key in this._unlockedPrivateKey with 0s.\r\n this._unlockedPrivateKey.overwrite(PrivateKey.unserialize(new SerialBuffer(this._unlockedPrivateKey.serializedSize)));\r\n // Then, reset it.\r\n this._unlockedPrivateKey = null;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @return {Promise<PrivateKey>}\r\n * @private\r\n */\r\n async _otpPrivateKey(key) {\r\n return new PrivateKey(await CryptoUtils.otpKdfLegacy(this._privateKey.serialize(), key, this._lockSalt, KeyPair.LOCK_KDF_ROUNDS));\r\n }\r\n\r\n get isLocked() {\r\n return this._locked;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Uint8Array} key\r\n * @return {Promise.<KeyPair>}\r\n */\r\n static async fromEncrypted(buf, key) {\r\n const privateKey = await Secret.fromEncrypted(buf, key);\r\n if (privateKey.type !== Secret.Type.PRIVATE_KEY) throw new Error('Expected privateKey, got Entropy');\r\n return KeyPair.derive(privateKey);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @return {Promise.<SerialBuffer>}\r\n */\r\n exportEncrypted(key) {\r\n return this._privateKey.exportEncrypted(key);\r\n }\r\n\r\n /** @type {number} */\r\n get encryptedSize() {\r\n return this._privateKey.encryptedSize;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof KeyPair && super.equals(o);\r\n }\r\n}\r\nKeyPair.LOCK_KDF_ROUNDS = 256;\r\n\r\n\r\nClass.register(KeyPair);\r\n","class Entropy extends Secret {\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super(Secret.Type.ENTROPY, Entropy.PURPOSE_ID);\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Entropy.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @return {Entropy}\r\n */\r\n static generate() {\r\n const entropy = new Uint8Array(Entropy.SIZE);\r\n CryptoWorker.lib.getRandomValues(entropy);\r\n return new Entropy(entropy);\r\n }\r\n\r\n /**\r\n * @param {string} [password]\r\n * @param {Array.<string>} [wordlist]\r\n * @return {ExtendedPrivateKey}\r\n */\r\n toExtendedPrivateKey(password, wordlist) {\r\n return MnemonicUtils.mnemonicToExtendedPrivateKey(this.toMnemonic(wordlist), password);\r\n }\r\n\r\n /**\r\n * @param {Array.<string>} [wordlist]\r\n * @return {Array.<string>}\r\n */\r\n toMnemonic(wordlist) {\r\n return MnemonicUtils.entropyToMnemonic(this, wordlist);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Entropy}\r\n */\r\n static unserialize(buf) {\r\n return new Entropy(buf.read(Entropy.SIZE));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Entropy.SIZE;\r\n }\r\n\r\n /**\r\n * Overwrite this entropy with a replacement in-memory\r\n * @param {Entropy} entropy\r\n */\r\n overwrite(entropy) {\r\n this._obj.set(entropy._obj);\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Entropy && super.equals(o);\r\n }\r\n}\r\n\r\nEntropy.SIZE = Secret.SIZE;\r\nEntropy.PURPOSE_ID = 0x42000002;\r\n\r\nClass.register(Entropy);\r\n","class ExtendedPrivateKey extends Serializable {\r\n /**\r\n * @param {PrivateKey} key\r\n * @param {Uint8Array} chainCode\r\n * @private\r\n */\r\n constructor(key, chainCode) {\r\n super();\r\n if (!(key instanceof PrivateKey)) throw new Error('ExtendedPrivateKey: Invalid key');\r\n if (!(chainCode instanceof Uint8Array)) throw new Error('ExtendedPrivateKey: Invalid chainCode');\r\n if (chainCode.length !== ExtendedPrivateKey.CHAIN_CODE_SIZE) throw new Error('ExtendedPrivateKey: Invalid chainCode length');\r\n this._key = key;\r\n this._chainCode = chainCode;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} seed\r\n * @return {ExtendedPrivateKey}\r\n */\r\n static generateMasterKey(seed) {\r\n const bCurve = BufferUtils.fromAscii('secp256k1 seed');\r\n const hash = CryptoUtils.computeHmacSha512(bCurve, seed);\r\n return new ExtendedPrivateKey(new PrivateKey(hash.slice(0, 32)), hash.slice(32));\r\n }\r\n\r\n /**\r\n * @param {number} index\r\n * @return {ExtendedPrivateKey}\r\n */\r\n derive(index) {\r\n // Only hardened derivation is allowed for ed25519.\r\n if (index < 0x80000000) index += 0x80000000;\r\n\r\n const data = new SerialBuffer(1 + PrivateKey.SIZE + 4);\r\n data.writeUint8(0);\r\n this._key.serialize(data);\r\n data.writeUint32(index);\r\n\r\n const hash = CryptoUtils.computeHmacSha512(this._chainCode, data);\r\n return new ExtendedPrivateKey(new PrivateKey(hash.slice(0, 32)), hash.slice(32));\r\n }\r\n\r\n /**\r\n * @param {string} path\r\n * @return {boolean}\r\n */\r\n static isValidPath(path) {\r\n if (path.match(/^m(\\/[0-9]+')*$/) === null) return false;\r\n\r\n // Overflow check.\r\n const segments = path.split('/');\r\n for (let i = 1; i < segments.length; i++) {\r\n if (!NumberUtils.isUint32(parseInt(segments[i]))) return false;\r\n }\r\n\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {string} path\r\n * @return {ExtendedPrivateKey}\r\n */\r\n derivePath(path) {\r\n if (!ExtendedPrivateKey.isValidPath(path)) throw new Error('Invalid path');\r\n\r\n let extendedKey = this;\r\n const segments = path.split('/');\r\n for (let i = 1; i < segments.length; i++) {\r\n const index = parseInt(segments[i]);\r\n extendedKey = extendedKey.derive(index);\r\n }\r\n return extendedKey;\r\n }\r\n\r\n /**\r\n * @param {string} path\r\n * @param {Uint8Array} seed\r\n * @return {ExtendedPrivateKey}\r\n */\r\n static derivePathFromSeed(path, seed) {\r\n let extendedKey = ExtendedPrivateKey.generateMasterKey(seed);\r\n return extendedKey.derivePath(path);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {ExtendedPrivateKey}\r\n */\r\n static unserialize(buf) {\r\n const privateKey = PrivateKey.unserialize(buf);\r\n const chainCode = buf.read(ExtendedPrivateKey.CHAIN_CODE_SIZE);\r\n return new ExtendedPrivateKey(privateKey, chainCode);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._key.serialize(buf);\r\n buf.write(this._chainCode);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this._key.serializedSize + ExtendedPrivateKey.CHAIN_CODE_SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof ExtendedPrivateKey && super.equals(o);\r\n }\r\n\r\n /**\r\n * @type {PrivateKey}\r\n */\r\n get privateKey() {\r\n return this._key;\r\n }\r\n\r\n /**\r\n * @return {Address}\r\n */\r\n toAddress() {\r\n return PublicKey.derive(this._key).toAddress();\r\n }\r\n}\r\n\r\nExtendedPrivateKey.CHAIN_CODE_SIZE = 32;\r\n\r\nClass.register(ExtendedPrivateKey);\r\n","class RandomSecret extends Serializable {\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== RandomSecret.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {RandomSecret}\r\n */\r\n static unserialize(buf) {\r\n return new RandomSecret(buf.read(RandomSecret.SIZE));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return RandomSecret.SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof RandomSecret && super.equals(o);\r\n }\r\n}\r\n\r\nRandomSecret.SIZE = 32;\r\n\r\nClass.register(RandomSecret);\r\n","class Signature extends Serializable {\r\n /**\r\n * @param {Signature} o\r\n * @returns {Signature}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n // FIXME Move this to Crypto class.\r\n const obj = new Uint8Array(o._obj);\r\n return new Signature(obj);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Signature.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @param {PublicKey} publicKey\r\n * @param {Uint8Array} data\r\n * @return {Signature}\r\n */\r\n static create(privateKey, publicKey, data) {\r\n return new Signature(Signature._signatureCreate(privateKey._obj, publicKey.compress(), data));\r\n }\r\n\r\n /**\r\n * @param {Commitment} commitment\r\n * @param {Array.<PartialSignature>} signatures\r\n * @return {Signature}\r\n */\r\n static fromPartialSignatures(commitment, signatures) {\r\n const raw = Signature._combinePartialSignatures(commitment.serialize(), signatures.map(s => s.serialize()));\r\n return new Signature(raw);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Signature}\r\n */\r\n static unserialize(buf) {\r\n return new Signature(buf.read(Signature.SIZE));\r\n }\r\n\r\n /**\r\n * @param {Signature|Uint8Array|string} o\r\n * @return {Signature}\r\n */\r\n static fromAny(o) {\r\n if (!o) throw new Error('Invalid signature format');\r\n if (o instanceof Signature) return o;\r\n try {\r\n return new Signature(BufferUtils.fromAny(o, Signature.SIZE));\r\n } catch (e) {\r\n throw new Error('Invalid signature format');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Signature.SIZE;\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {Uint8Array} data\r\n * @return {boolean}\r\n */\r\n verify(publicKey, data) {\r\n return Signature._signatureVerify(publicKey.compress(), data, this._obj);\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Signature && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} combinedCommitment\r\n * @param {Array.<Uint8Array>} partialSignatures\r\n * @returns {Uint8Array}\r\n */\r\n static _combinePartialSignatures(combinedCommitment, partialSignatures) {\r\n return Signature._aggregatePartialSignatures(partialSignatures);\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} partialSignatures\r\n * @returns {Uint8Array}\r\n */\r\n static _aggregatePartialSignatures(partialSignatures) {\r\n return partialSignatures.reduce((sigA, sigB) => {\r\n if (!sigA) return sigB;\r\n const r = sigA.slice(0, PartialSignature.HALF_SIZE);\r\n const sA = sigA.slice(PartialSignature.HALF_SIZE);\r\n const sB = sigB.slice(PartialSignature.HALF_SIZE);\r\n const sum = Signature._scalarsAdd(sA, sB);\r\n return BufferUtils.concatTypedArrays(r, sum);\r\n });\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} a\r\n * @param {Uint8Array} b\r\n * @returns {Uint8Array}\r\n */\r\n static _scalarsAdd(a, b) {\r\n if (a.byteLength !== PartialSignature.HALF_SIZE || b.byteLength !== PartialSignature.HALF_SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PartialSignature.HALF_SIZE);\r\n NodeNative.node_secp256k1_add_scalars(out, new Uint8Array(a), new Uint8Array(b));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOutSum = Module.stackAlloc(PartialSignature.HALF_SIZE);\r\n const wasmInA = Module.stackAlloc(a.length);\r\n const wasmInB = Module.stackAlloc(b.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInA, a.length).set(a);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInB, b.length).set(b);\r\n Module._secp256k1_add_scalars(wasmOutSum, wasmInA, wasmInB);\r\n const sum = new Uint8Array(PartialSignature.HALF_SIZE);\r\n sum.set(new Uint8Array(Module.HEAPU8.buffer, wasmOutSum, PartialSignature.HALF_SIZE));\r\n return sum;\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} privateKey\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} message\r\n * @returns {Uint8Array}\r\n */\r\n static _signatureCreate(privateKey, publicKey, message) {\r\n if (privateKey.byteLength !== PrivateKey.SIZE || publicKey.byteLength != PublicKey.COMPRESSED_SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(Signature.SIZE);\r\n NodeNative.node_secp256k1_schnorr_sign(out, new Uint8Array(message), new Uint8Array(publicKey), new Uint8Array(privateKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n const rdmBuff = new Uint8Array(Module.HEAP8.buffer, rdm, 32);\r\n rdmBuff.set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n const wasmOutSignature = Module.stackAlloc(Signature.SIZE);\r\n const signatureBuffer = new Uint8Array(Module.HEAP8.buffer, wasmOutSignature, Signature.SIZE);\r\n const wasmInMessage = Module.stackAlloc(message.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInMessage, message.length).set(message);\r\n const wasmInPubKey = Module.stackAlloc(publicKey.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInPubKey, publicKey.length).set(publicKey);\r\n const wasmInPrivKey = Module.stackAlloc(privateKey.length);\r\n const privKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmInPrivKey, privateKey.length);\r\n privKeyBuffer.set(privateKey);\r\n\r\n Module._secp256k1_schnorr_sign(wasmOutSignature, wasmInMessage, message.byteLength, wasmInPubKey, wasmInPrivKey);\r\n privKeyBuffer.fill(0);\r\n\r\n const signature = new Uint8Array(Signature.SIZE);\r\n signature.set(signatureBuffer);\r\n return signature;\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n \r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} signature\r\n * @returns {boolean}\r\n */\r\n static _signatureVerify(publicKey, message, signature) {\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const res = !!NodeNative.node_secp256k1_schnorr_verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return res;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n const rdmBuff = new Uint8Array(Module.HEAP8.buffer, rdm, 32);\r\n rdmBuff.set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n \r\n const wasmInPubKey = Module.stackAlloc(publicKey.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInPubKey, publicKey.length).set(publicKey);\r\n const wasmInMessage = Module.stackAlloc(message.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInMessage, message.length).set(message);\r\n const wasmInSignature = Module.stackAlloc(signature.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInSignature, signature.length).set(signature);\r\n\r\n return !!Module._secp256k1_schnorr_verify(wasmInSignature, wasmInMessage, message.byteLength, wasmInPubKey);\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nSignature.SIZE = 64;\r\n\r\nClass.register(Signature);\r\n","class Commitment extends Serializable {\r\n /**\r\n * @param {Commitment} o\r\n * @returns {Commitment}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n return new Commitment(new Uint8Array(o._obj));\r\n }\r\n\r\n /**\r\n * @param {Array.<Commitment>} commitments\r\n * @return {Commitment}\r\n */\r\n static sum(commitments) {\r\n return new Commitment(Commitment._commitmentsAggregate(commitments.map(c => c._obj)));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Commitment.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @return {Uint8Array}\r\n */\r\n compress() {\r\n return PublicKey._compressPublicKey(this._obj);\r\n }\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Commitment}\r\n */\r\n static unserialize(buf) {\r\n return new Commitment(buf.read(Commitment.SIZE));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Commitment.SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Commitment && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} commitments\r\n * @returns {Uint8Array}\r\n */\r\n static _commitmentsAggregate(commitments) {\r\n if (commitments.some(commitment => commitment.byteLength !== Commitment.SIZE)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const concatenatedCommitments = new Uint8Array(commitments.length * Commitment.SIZE);\r\n for (let i = 0; i < commitments.length; ++i) {\r\n concatenatedCommitments.set(commitments[i], i * Commitment.SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Commitment.SIZE);\r\n NodeNative.node_secp256k1_aggregate_commitments(out, concatenatedCommitments, commitments.length, Commitment.SIZE);\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(Commitment.SIZE);\r\n const wasmInCommitments = Module.stackAlloc(concatenatedCommitments.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInCommitments, concatenatedCommitments.length).set(concatenatedCommitments);\r\n Module._secp256k1_aggregate_commitments(wasmOut, wasmInCommitments, commitments.length, Commitment.SIZE);\r\n const aggCommitments = new Uint8Array(Commitment.SIZE);\r\n aggCommitments.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, Commitment.SIZE));\r\n return aggCommitments;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nCommitment.COMPRESSED_SIZE = 33;\r\nCommitment.SIZE = 65;\r\n\r\nClass.register(Commitment);\r\n","class CommitmentPair extends Serializable {\r\n /**\r\n * @param {RandomSecret} secret\r\n * @param {Commitment} commitment\r\n * @private\r\n */\r\n constructor(secret, commitment) {\r\n super();\r\n if (!(secret instanceof RandomSecret)) throw new Error('Primitive: Invalid type');\r\n if (!(commitment instanceof Commitment)) throw new Error('Primitive: Invalid type');\r\n this._secret = secret;\r\n this._commitment = commitment;\r\n }\r\n\r\n /**\r\n * @return {CommitmentPair}\r\n */\r\n static generate() {\r\n const randomness = new Uint8Array(CommitmentPair.RANDOMNESS_SIZE);\r\n CryptoWorker.lib.getRandomValues(randomness);\r\n const raw = CommitmentPair._commitmentCreate(randomness);\r\n return new CommitmentPair(new RandomSecret(raw.secret), new Commitment(raw.commitment));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {CommitmentPair}\r\n */\r\n static unserialize(buf) {\r\n const secret = RandomSecret.unserialize(buf);\r\n const commitment = Commitment.unserialize(buf);\r\n return new CommitmentPair(secret, commitment);\r\n }\r\n\r\n /**\r\n * @param {string} hexBuf\r\n * @return {CommitmentPair}\r\n */\r\n static fromHex(hexBuf) {\r\n return this.unserialize(BufferUtils.fromHex(hexBuf));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this.secret.serialize(buf);\r\n this.commitment.serialize(buf);\r\n return buf;\r\n }\r\n\r\n /** @type {RandomSecret} */\r\n get secret() {\r\n return this._secret;\r\n }\r\n\r\n /** @type {Commitment} */\r\n get commitment() {\r\n return this._commitment;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this.secret.serializedSize + this.commitment.serializedSize;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof CommitmentPair && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} randomness\r\n * @returns {{commitment:Uint8Array, secret:Uint8Array}}\r\n */\r\n static _commitmentCreate(randomness) {\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const commitment = new Uint8Array(Commitment.SIZE);\r\n const secret = new Uint8Array(PrivateKey.SIZE);\r\n NodeNative.node_secp256k1_create_commitment(secret, commitment, randomness);\r\n NodeNative.node_secp256k1_ctx_release();\r\n return {commitment, secret};\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOutCommitment = Module.stackAlloc(Commitment.SIZE);\r\n const wasmOutSecret = Module.stackAlloc(PrivateKey.SIZE);\r\n const wasmIn = Module.stackAlloc(randomness.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, randomness.length).set(randomness);\r\n const res = Module._secp256k1_create_commitment(wasmOutSecret, wasmOutCommitment, Commitment.SIZE, wasmIn);\r\n if (res !== 1) {\r\n throw new Error(`Secret must not be 0 or 1: ${res}`);\r\n }\r\n const commitment = new Uint8Array(Commitment.SIZE);\r\n const secret = new Uint8Array(PrivateKey.SIZE);\r\n commitment.set(new Uint8Array(Module.HEAPU8.buffer, wasmOutCommitment, Commitment.SIZE));\r\n secret.set(new Uint8Array(Module.HEAPU8.buffer, wasmOutSecret, PrivateKey.SIZE));\r\n return {commitment, secret};\r\n } catch (e) {\r\n Log.w(CommitmentPair, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nCommitmentPair.SERIALIZED_SIZE = RandomSecret.SIZE + Signature.SIZE;\r\nCommitmentPair.RANDOMNESS_SIZE = 32;\r\n\r\nClass.register(CommitmentPair);\r\n","class PartialSignature extends Serializable {\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== PartialSignature.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @param {PublicKey} publicKey\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @param {RandomSecret} secret\r\n * @param {Commitment} aggregateCommitment\r\n * @param {Uint8Array} data\r\n * @return {PartialSignature}\r\n */\r\n static create(privateKey, publicKey, publicKeys, secret, aggregateCommitment, data) {\r\n const raw = PartialSignature._delinearizedPartialSignatureCreate(publicKeys.map(o => o.compress()), privateKey._obj,\r\n publicKey.compress(), secret._obj, aggregateCommitment.compress(), data);\r\n return new PartialSignature(raw);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {PartialSignature}\r\n */\r\n static unserialize(buf) {\r\n return new PartialSignature(buf.read(PartialSignature.SIZE));\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return PartialSignature.SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof PartialSignature && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} publicKeys\r\n * @param {Uint8Array} privateKey\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} secret\r\n * @param {Uint8Array} aggregateCommitment\r\n * @param {Uint8Array} message\r\n * @returns {Uint8Array}\r\n */\r\n static _delinearizedPartialSignatureCreate(publicKeys, privateKey, publicKey, secret, aggregateCommitment, message) {\r\n if (publicKeys.some(publicKey => publicKey.byteLength !== PublicKey.COMPRESSED_SIZE)\r\n || privateKey.byteLength !== PrivateKey.SIZE\r\n || publicKey.byteLength !== PublicKey.COMPRESSED_SIZE\r\n || secret.byteLength !== RandomSecret.SIZE\r\n || aggregateCommitment.byteLength !== Commitment.COMPRESSED_SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n const concatenatedPublicKeys = new Uint8Array(publicKeys.length * PublicKey.COMPRESSED_SIZE);\r\n for (let i = 0; i < publicKeys.length; ++i) {\r\n concatenatedPublicKeys.set(publicKeys[i], i * PublicKey.COMPRESSED_SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(PartialSignature.SIZE);\r\n NodeNative.node_secp256k1_partial_sign(out, new Uint8Array(message), new Uint8Array(aggregateCommitment), new Uint8Array(secret), new Uint8Array(concatenatedPublicKeys), publicKeys.length, new Uint8Array(publicKey), new Uint8Array(privateKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOut = Module.stackAlloc(PartialSignature.SIZE);\r\n const wasmInPublicKeys = Module.stackAlloc(concatenatedPublicKeys.length);\r\n const wasmInPrivateKey = Module.stackAlloc(privateKey.length);\r\n const wasmInPublicKey = Module.stackAlloc(publicKey.length);\r\n const wasmInSecret = Module.stackAlloc(secret.length);\r\n const wasmInCommitment = Module.stackAlloc(aggregateCommitment.length);\r\n const wasmInMessage = Module.stackAlloc(message.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeys, concatenatedPublicKeys.length).set(concatenatedPublicKeys);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPrivateKey, privateKey.length).set(privateKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKey, publicKey.length).set(publicKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInSecret, secret.length).set(secret);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInCommitment, aggregateCommitment.length).set(aggregateCommitment);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInMessage, message.length).set(message);\r\n Module._secp256k1_partial_sign(wasmOut, wasmInMessage, message.length, wasmInCommitment, wasmInSecret, wasmInPublicKeys, publicKeys.length, wasmInPublicKey, wasmInPrivateKey);\r\n const partialSignature = new Uint8Array(PartialSignature.SIZE);\r\n partialSignature.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PartialSignature.SIZE));\r\n return partialSignature;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nPartialSignature.HALF_SIZE = 32;\r\nPartialSignature.SIZE = 64;\r\nClass.register(PartialSignature);\r\n","class Address extends Serializable {\r\n /**\r\n * @param {Address} o\r\n * @returns {Address}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n const obj = new Uint8Array(o._obj);\r\n return new Address(obj);\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @returns {Address}\r\n */\r\n static fromHash(hash) {\r\n return new Address(hash.subarray(-Address.SERIALIZED_SIZE));\r\n }\r\n\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Address.SERIALIZED_SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * Create Address object from binary form.\r\n * @param {SerialBuffer} buf Buffer to read from.\r\n * @return {Address} Newly created Account object.\r\n */\r\n static unserialize(buf) {\r\n return new Address(buf.read(Address.SERIALIZED_SIZE));\r\n }\r\n\r\n /**\r\n * Serialize this Address object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @returns {Uint8Array}\r\n */\r\n subarray(begin, end) {\r\n return this._obj.subarray(begin, end);\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get serializedSize() {\r\n return Address.SERIALIZED_SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Address\r\n && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Address|string} addr\r\n */\r\n static fromAny(addr) {\r\n if (addr instanceof Address) return addr;\r\n if (typeof addr === 'string') return Address.fromString(addr);\r\n throw new Error('Invalid address format');\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n toPlain() {\r\n return this.toUserFriendlyAddress();\r\n }\r\n\r\n static fromString(str) {\r\n try {\r\n return Address.fromUserFriendlyAddress(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Address.fromHex(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Address.fromBase64(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n throw new Error('Invalid address format');\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @return {Address}\r\n */\r\n static fromBase64(base64) {\r\n return new Address(BufferUtils.fromBase64(base64));\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @return {Address}\r\n */\r\n static fromHex(hex) {\r\n return new Address(BufferUtils.fromHex(hex));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @return {Address}\r\n */\r\n static fromBech32(str) {\r\n if (!this.isBech32Address(str)) {\r\n throw new Error('Invalid Bech32 Address');\r\n }\r\n\r\n return new Address(Bech32.fromBech32(str));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @return {Address}\r\n */\r\n static fromUserFriendlyAddress(str) {\r\n return Address.fromHex(str);\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBech32() {\r\n return Bech32.toBech32(this.serialize());\r\n }\r\n\r\n /**\r\n * @param {boolean} [withSpaces]\r\n * @return {string}\r\n */\r\n toUserFriendlyAddress(withSpaces = true) {\r\n return this.toHex();\r\n }\r\n\r\n /**\r\n * @param {string} [addr]\r\n * @return {boolean}\r\n */\r\n static isBech32Address(addr) {\r\n return Bech32.isBech32Address(addr);\r\n }\r\n}\r\n\r\nAddress.SERIALIZED_SIZE = 20;\r\nAddress.HEX_SIZE = 40;\r\nAddress.NULL = new Address(new Uint8Array(Address.SERIALIZED_SIZE));\r\nAddress.CONTRACT_CREATION = new Address(new Uint8Array(Address.SERIALIZED_SIZE));\r\nClass.register(Address);\r\n","// This code is taken from https://github.com/sipa/bech32/tree/bdc264f84014c234e908d72026b7b780122be11f/ref/javascript\r\n// Copyright (c) 2017 Pieter Wuille\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a copy\r\n// of this software and associated documentation files (the \"Software\"), to deal\r\n// in the Software without restriction, including without limitation the rights\r\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n// copies of the Software, and to permit persons to whom the Software is\r\n// furnished to do so, subject to the following conditions:\r\n//\r\n// The above copyright notice and this permission notice shall be included in\r\n// all copies or substantial portions of the Software.\r\n//\r\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n// THE SOFTWARE.\r\nclass Bech32 {\r\n /**\r\n * @param {SerialBuffer} values\r\n * @returns {number}\r\n */\r\n static polymod(values) {\r\n let chk = 1;\r\n \r\n for (let p = 0; p < values.length; ++p) {\r\n const top = chk >> 25;\r\n chk = ((chk & 0x1ffffff) << 5) ^ values[p];\r\n for (let i = 0; i < 5; ++i) {\r\n if ((top >> i) & 1) {\r\n chk ^= Bech32.GENERATOR[i];\r\n }\r\n }\r\n }\r\n return chk;\r\n };\r\n \r\n /**\r\n * @param {string} hrp\r\n * @returns {SerialBuffer}\r\n */\r\n static hrpExpand(hrp) {\r\n const ret = [];\r\n let p;\r\n for (p = 0; p < hrp.length; ++p) {\r\n ret.push(hrp.charCodeAt(p) >> 5);\r\n }\r\n ret.push(0);\r\n for (p = 0; p < hrp.length; ++p) {\r\n ret.push(hrp.charCodeAt(p) & 31);\r\n }\r\n return SerialBuffer.from(ret);\r\n };\r\n\r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {boolean}\r\n */\r\n static verifyChecksum(hrp, data) {\r\n // return Bech32.polymod(Buffer.concat([Bech32.hrpExpand(hrp), data])) === Bech32.ENCODING;\r\n return Bech32.polymod(SerialBuffer.concat([Bech32.hrpExpand(hrp), data])) === Bech32.ENCODING;\r\n }\r\n \r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {SerialBuffer}\r\n */\r\n static createChecksum(hrp, data) {\r\n const values = SerialBuffer.concat([Bech32.hrpExpand(hrp), data, SerialBuffer.from([0, 0, 0, 0, 0, 0])]);\r\n // const values = Buffer.concat([Buffer.from(Bech32.hrpExpand(hrp)), data, Buffer.from([0, 0, 0, 0, 0, 0])]);\r\n\r\n const mod = Bech32.polymod(values) ^ Bech32.ENCODING;\r\n const ret = [];\r\n for (let p = 0; p < 6; ++p) {\r\n ret.push((mod >> (5 * (5 - p))) & 31);\r\n }\r\n return SerialBuffer.from(ret);\r\n }\r\n \r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {string}\r\n */\r\n static bech32Encode(hrp, data) {\r\n const combined = SerialBuffer.concat([data, Bech32.createChecksum(hrp, data)]);\r\n let ret = hrp + '1';\r\n \r\n for (let p = 0; p < combined.length; ++p) {\r\n ret += Bech32.CHARSET.charAt(combined[p]);\r\n }\r\n\r\n return ret;\r\n };\r\n \r\n /**\r\n * @param {string} bechString\r\n * @returns {Object|null}\r\n */\r\n static bech32Decode(bechString) {\r\n let p;\r\n let hasLower = false;\r\n let hasUpper = false;\r\n for (p = 0; p < bechString.length; ++p) {\r\n if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {\r\n return null;\r\n }\r\n if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {\r\n hasLower = true;\r\n }\r\n if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {\r\n hasUpper = true;\r\n }\r\n }\r\n if (hasLower && hasUpper) {\r\n return null;\r\n }\r\n bechString = bechString.toLowerCase();\r\n const pos = bechString.lastIndexOf('1');\r\n if (pos < 1 || pos + 7 > bechString.length || bechString.length > 90) {\r\n return null;\r\n }\r\n const hrp = bechString.substring(0, pos);\r\n const data = [];\r\n for (p = pos + 1; p < bechString.length; ++p) {\r\n const d = Bech32.CHARSET.indexOf(bechString.charAt(p));\r\n if (d === -1) {\r\n return null;\r\n }\r\n data.push(d);\r\n }\r\n \r\n if (!Bech32.verifyChecksum(hrp, SerialBuffer.from(data))) {\r\n return null;\r\n }\r\n \r\n return { hrp, data: SerialBuffer.from(data.slice(0, data.length - 6)) };\r\n };\r\n\r\n /**\r\n * convertBits\r\n *\r\n * groups buffers of a certain width to buffers of the desired width.\r\n *\r\n * For example, converts byte buffers to buffers of maximum 5 bit numbers,\r\n * padding those numbers as necessary. Necessary for encoding addresses as bech32 ones.\r\n *\r\n * @param {SerialBuffer} data\r\n * @param {number} fromWidth\r\n * @param {number} toWidth\r\n * @param {boolean} pad\r\n * @returns {SerialBuffer|null}\r\n */\r\n static convertBits(data, fromWidth, toWidth, pad = true) {\r\n let acc = 0;\r\n let bits = 0;\r\n const ret = [];\r\n const maxv = (1 << toWidth) - 1;\r\n \r\n for (let p = 0; p < data.length; ++p) {\r\n const value = data[p];\r\n if (value < 0 || value >> fromWidth !== 0) {\r\n return null;\r\n }\r\n acc = (acc << fromWidth) | value;\r\n bits += fromWidth;\r\n while (bits >= toWidth) {\r\n bits -= toWidth;\r\n ret.push((acc >> bits) & maxv);\r\n }\r\n }\r\n\r\n if (pad) {\r\n if (bits > 0) {\r\n ret.push((acc << (toWidth - bits)) & maxv);\r\n }\r\n } else if (bits >= fromWidth || (acc << (toWidth - bits)) & maxv) {\r\n return null;\r\n }\r\n\r\n return SerialBuffer.from(ret);\r\n };\r\n\r\n /**\r\n *\r\n * bech32Encodes a canonical 20-byte address as a bech32 address.\r\n *\r\n * The expected format is bc1<address><checksum> where address and checksum\r\n * are the result of bech32 encoding a Buffer containing the address bytes.\r\n *\r\n * @param {SerialBuffer} 20 byte canonical address\r\n * @returns {string} 38 char bech32 bech32Encoded Feechain address\r\n */\r\n static toBech32(address, useHRP = Bech32.HRP) {\r\n const addrBz = Bech32.convertBits(SerialBuffer.from(address), 8, 5);\r\n\r\n if (addrBz === null) {\r\n throw new Error('Could not convert byte Buffer to 5-bit Buffer');\r\n }\r\n const version = 0; // first byte version same as bitcoin\r\n return Bech32.bech32Encode(useHRP, SerialBuffer.concat([SerialBuffer.from([version]), addrBz]));\r\n };\r\n\r\n /**\r\n * fromBech32Address\r\n *\r\n * @param {string} address - a valid bech32 address\r\n * @returns {SerialBuffer} a canonical 20-byte address\r\n */\r\n static fromBech32(address, useHRP = Bech32.HRP) {\r\n const res = Bech32.bech32Decode(address);\r\n\r\n if (res === null) {\r\n throw new Error('Invalid bech32 address');\r\n }\r\n\r\n const { hrp, data } = res;\r\n\r\n if (hrp !== useHRP) {\r\n throw new Error(`Expected hrp to be ${useHRP} but got ${hrp}`);\r\n }\r\n\r\n const buf = Bech32.convertBits(data.slice(1), 5, 8, false);\r\n\r\n if (buf === null) {\r\n throw new Error('Could not convert buffer to bytes');\r\n }\r\n \r\n return new SerialBuffer(buf);\r\n };\r\n\r\n /**\r\n *\r\n * @param {string} raw \r\n * @returns {boolean}\r\n */\r\n static isBech32Address(raw) {\r\n return !!raw.match(/^bc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{39}/);\r\n };\r\n}\r\n\r\nBech32.ENCODING = 1; // bech32: 1, bech32m: 0x2bc830a3\r\nBech32.HRP = 'bc';\r\nBech32.CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\r\nBech32.GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\r\nClass.register(Bech32);\r\n","/**\r\n * @abstract\r\n */\r\nclass Account {\r\n /**\r\n * @param {Account.Type} type\r\n * @param {BigNumber|number|string} balance\r\n */\r\n constructor(type, balance) {\r\n const bigBalance = new BigNumber(balance);\r\n if (!NumberUtils.isUint8(type)) throw new Error('Malformed type');\r\n if (!NumberUtils.isUint128(bigBalance)) throw new Error('Malformed balance');\r\n\r\n /** @type {Account.Type} */\r\n this._type = type;\r\n /** @type {BigNumber} */\r\n this._balance = bigBalance;\r\n }\r\n\r\n /**\r\n * Create Account object from binary form.\r\n * @param {SerialBuffer} buf Buffer to read from.\r\n * @return {Account} Newly created Account object.\r\n */\r\n static unserialize(buf) {\r\n const type = /** @type {Account.Type} */ buf.readUint8();\r\n buf.readPos--;\r\n\r\n if (!Account.TYPE_MAP.has(type)) {\r\n throw new Error('Unknown account type');\r\n }\r\n\r\n return Account.TYPE_MAP.get(type).unserialize(buf);\r\n }\r\n\r\n /**\r\n * Serialize this Account object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(this._type);\r\n buf.writeUint128(this._balance);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + /*balance*/ 16;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return BufferUtils.equals(this.serialize(), o.serialize());\r\n }\r\n\r\n toString() {\r\n return `Account{type=${this._type}, balance=${this._balance.toString()}`;\r\n }\r\n\r\n /**\r\n * @param {Account|object} o\r\n */\r\n static fromAny(o) {\r\n if (o instanceof Account) return o;\r\n return Account.fromPlain(o);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @returns {Account}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain || plain.type === undefined) throw new Error('Invalid account');\r\n const type = Account.Type.fromAny(plain.type);\r\n return Account.TYPE_MAP.get(type).fromPlain(plain);\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n return {\r\n type: Account.Type.toString(this.type),\r\n balance: this.balance.toString()\r\n };\r\n }\r\n\r\n /**\r\n * @type {number} Account balance\r\n */\r\n get balance() {\r\n return this._balance;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get type() {\r\n return this._type;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) { throw new Error('Not yet implemented.'); }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n if (!revert) {\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(0)) {\r\n throw new Account.BalanceError();\r\n }\r\n if (blockHeight < transaction.validityStartHeight\r\n || blockHeight >= transaction.validityStartHeight + Policy.TRANSACTION_VALIDITY_WINDOW) {\r\n throw new Account.ValidityError();\r\n }\r\n if (transactionsCache.containsTransaction(transaction)) {\r\n throw new Account.DoubleTransactionError();\r\n }\r\n return this.withBalance(newBalance);\r\n } else {\r\n if (blockHeight < transaction.validityStartHeight\r\n || blockHeight >= transaction.validityStartHeight + Policy.TRANSACTION_VALIDITY_WINDOW) {\r\n throw new Account.ValidityError();\r\n }\r\n return this.withBalance(this._balance.plus(transaction.value).plus(transaction.fee));\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert) {\r\n return this.withBalance(this._balance.plus(transaction.value));\r\n } else {\r\n const newBalance = this._balance.minus(transaction.value);\r\n if (newBalance.lt(0)) {\r\n throw new Account.BalanceError();\r\n }\r\n return this.withBalance(newBalance);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n throw new Error('Not yet implemented');\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isInitial() {\r\n return this === Account.INITIAL;\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isToBePruned() {\r\n return this._balance.eq(0) && !this.isInitial();\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n return {};\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n return {};\r\n }\r\n}\r\n\r\n/**\r\n * Enum for Account types.\r\n * Non-zero values are contracts.\r\n * @enum\r\n */\r\nAccount.Type = {\r\n /**\r\n * Basic account type.\r\n * @see {BasicAccount}\r\n */\r\n BASIC: 0,\r\n /**\r\n * Account with vesting functionality.\r\n * @see {VestingContract}\r\n */\r\n VESTING: 1,\r\n /**\r\n * Hashed Time-Locked Contract\r\n * @see {HashedTimeLockedContract}\r\n */\r\n HTLC: 2\r\n};\r\n/**\r\n * @param {Account.Type} type\r\n * @return {string}\r\n */\r\nAccount.Type.toString = function(type) {\r\n switch (type) {\r\n case Account.Type.BASIC: return 'basic';\r\n case Account.Type.VESTING: return 'vesting';\r\n case Account.Type.HTLC: return 'htlc';\r\n }\r\n throw new Error('Invalid account type');\r\n};\r\n/**\r\n * @param {Account.Type|string} type\r\n * @return {Account.Type}\r\n */\r\nAccount.Type.fromAny = function(type) {\r\n if (typeof type === 'number') return type;\r\n switch (type) {\r\n case 'basic': return Account.Type.BASIC;\r\n case 'vesting': return Account.Type.VESTING;\r\n case 'htlc': return Account.Type.HTLC;\r\n }\r\n throw new Error('Invalid account type');\r\n};\r\n/**\r\n * @type {Map.<Account.Type, {\r\n * copy: function(o: *):Account,\r\n * unserialize: function(buf: SerialBuffer):Account,\r\n * create: function(balance: BigNumber|number|string, blockHeight: number, transaction: Transaction):Account,\r\n * verifyOutgoingTransaction: function(transaction: Transaction):boolean,\r\n * verifyIncomingTransaction: function(transaction: Transaction):boolean,\r\n * fromPlain: function(o: object):Account,\r\n * dataToPlain: function(data: Uint8Array):object,\r\n * proofToPlain: function(proof: Uint8Array):object\r\n * }>}\r\n */\r\nAccount.TYPE_MAP = new Map();\r\nAccount.BalanceError = class extends Error { constructor() { super('Balance Error!'); }};\r\nAccount.DoubleTransactionError = class extends Error { constructor() { super('Double Transaction Error!'); }};\r\nAccount.ProofError = class extends Error { constructor() { super('Proof Error!'); }};\r\nAccount.ValidityError = class extends Error { constructor() { super('Validity Error!'); }};\r\nClass.register(Account);\r\n","/**\r\n * This is a classic account that can send all his funds and receive any transaction.\r\n * All outgoing transactions are signed using the key corresponding to this address.\r\n */\r\nclass BasicAccount extends Account {\r\n /**\r\n * @param {BasicAccount} o\r\n * @returns {BasicAccount}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n return new BasicAccount(o._balance);\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} [balance]\r\n */\r\n constructor(balance = 0) {\r\n super(Account.Type.BASIC, balance);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {BasicAccount}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.BASIC) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n return new BasicAccount(balance);\r\n }\r\n\r\n /**\r\n * @param {object} o\r\n */\r\n static fromPlain(o) {\r\n if (!o) throw new Error('Invalid account');\r\n return new BasicAccount(o.balance);\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof BasicAccount\r\n && this._type === o._type\r\n && this._balance.eq(o._balance);\r\n }\r\n\r\n toString() {\r\n return `BasicAccount{balance=${this._balance.toString()}}`;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n return SignatureProof.verifyTransaction(transaction);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n if (transaction.data.byteLength > 64) return false;\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new BasicAccount(balance);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert) {\r\n const isContractCreation = transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION);\r\n const isTypeChange = transaction.recipientType !== this._type;\r\n if (isContractCreation !== isTypeChange) {\r\n throw new Error('Data Error!');\r\n }\r\n }\r\n return super.withIncomingTransaction(transaction, blockHeight, revert);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n if (!revert && transaction.recipientType !== this._type && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Contract creation\r\n return Account.TYPE_MAP.get(transaction.recipientType).create(this._balance, blockHeight, transaction);\r\n }\r\n return this;\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isInitial() {\r\n return this._balance && this._balance.eq(0);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n return Account.dataToPlain(data);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const signatureProof = SignatureProof.unserialize(new SerialBuffer(proof));\r\n return {\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nAccount.INITIAL = new BasicAccount(0);\r\nAccount.TYPE_MAP.set(Account.Type.BASIC, BasicAccount);\r\nClass.register(BasicAccount);\r\n","class Contract extends Account {\r\n /**\r\n * @param {Account.Type} type\r\n * @param {BigNumber|number|string} balance\r\n */\r\n constructor(type, balance) {\r\n super(type, balance);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n if (!transaction.recipient.equals(transaction.getContractCreationAddress())) {\r\n return false;\r\n }\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Contract already created\r\n throw new Error('Data error');\r\n }\r\n return super.withIncomingTransaction(transaction, blockHeight, revert);\r\n }\r\n\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n if (revert && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Revert contract creation\r\n return new BasicAccount(this.balance);\r\n }\r\n return this;\r\n }\r\n}\r\n\r\nClass.register(Contract);\r\n","class HashedTimeLockedContract extends Contract {\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {Address} sender\r\n * @param {Address} recipient\r\n * @param {Hash} hashRoot\r\n * @param {number} hashCount\r\n * @param {number} timeout\r\n * @param {BigNumber|number|string} totalAmount\r\n */\r\n constructor(balance = 0, sender = Address.NULL, recipient = Address.NULL, hashRoot = Hash.NULL, hashCount = 1, timeout = 0, totalAmount = balance) {\r\n super(Account.Type.HTLC, balance);\r\n const bigTotalAmount = new BigNumber(totalAmount);\r\n if (!(sender instanceof Address)) throw new Error('Malformed sender address');\r\n if (!(recipient instanceof Address)) throw new Error('Malformed recipient address');\r\n if (!(hashRoot instanceof Hash)) throw new Error('Malformed hashRoot');\r\n if (!NumberUtils.isUint8(hashCount) || hashCount === 0) throw new Error('Malformed hashCount');\r\n if (!NumberUtils.isUint32(timeout)) throw new Error('Malformed timeout');\r\n if (!NumberUtils.isUint128(bigTotalAmount)) throw new Error('Malformed totalAmount');\r\n\r\n /** @type {Address} */\r\n this._sender = sender;\r\n /** @type {Address} */\r\n this._recipient = recipient;\r\n /** @type {Hash} */\r\n this._hashRoot = hashRoot;\r\n /** @type {number} */\r\n this._hashCount = hashCount;\r\n /** @type {number} */\r\n this._timeout = timeout;\r\n /** @type {number} */\r\n this._totalAmount = bigTotalAmount;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {number} blockHeight\r\n * @param {Transaction} transaction\r\n */\r\n static create(balance, blockHeight, transaction) {\r\n const buf = new SerialBuffer(transaction.data);\r\n\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n\r\n return new HashedTimeLockedContract(balance, sender, recipient, hashRoot, hashCount, timeout);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {HashedTimeLockedContract}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.HTLC) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n const totalAmount = buf.readUint128();\r\n return new HashedTimeLockedContract(balance, sender, recipient, hashRoot, hashCount, timeout, totalAmount);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid account');\r\n return new HashedTimeLockedContract(plain.balance, Address.fromAny(plain.sender), Address.fromAny(plain.recipient), Hash.fromAny(plain.hashRoot, Hash.Algorithm.fromAny(plain.hashAlgorithm)), plain.hashCount, plain.timeout, plain.totalAmount);\r\n }\r\n\r\n\r\n /**\r\n * Serialize this HTLC object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n super.serialize(buf);\r\n this._sender.serialize(buf);\r\n this._recipient.serialize(buf);\r\n buf.writeUint8(this._hashRoot.algorithm);\r\n this._hashRoot.serialize(buf);\r\n buf.writeUint8(this._hashCount);\r\n buf.writeUint32(this._timeout);\r\n buf.writeUint128(this._totalAmount);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return super.serializedSize\r\n + this._sender.serializedSize\r\n + this._recipient.serializedSize\r\n + /*hashAlgorithm*/ 1\r\n + this._hashRoot.serializedSize\r\n + /*hashCount*/ 1\r\n + /*timeout*/ 4\r\n + /*totalAmount*/ 16;\r\n }\r\n\r\n /** @type {Address} */\r\n get sender() {\r\n return this._sender;\r\n }\r\n\r\n /** @type {Address} */\r\n get recipient() {\r\n return this._recipient;\r\n }\r\n\r\n /** @type {Hash.Algorithm} */\r\n get hashAlgorithm() {\r\n return this._hashRoot.algorithm;\r\n }\r\n\r\n /** @type {Hash} */\r\n get hashRoot() {\r\n return this._hashRoot;\r\n }\r\n\r\n /** @type {number} */\r\n get hashCount() {\r\n return this._hashCount;\r\n }\r\n\r\n /** @type {number} */\r\n get timeout() {\r\n return this._timeout;\r\n }\r\n\r\n /** @type {number} */\r\n get totalAmount() {\r\n return this._totalAmount;\r\n }\r\n\r\n toString() {\r\n return `HashedTimeLockedContract{balance=${this._balance.toString()}, sender=${this._sender.toUserFriendlyAddress(false)}, recipient=${this._sender.toUserFriendlyAddress(false)}, amount=${this._totalAmount.toString()}/${this._hashCount}, timeout=${this._timeout}}`;\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n const plain = super.toPlain();\r\n plain.sender = this.sender.toPlain();\r\n plain.recipient = this.recipient.toPlain();\r\n plain.hashAlgorithm = Hash.Algorithm.toString(this.hashRoot.algorithm);\r\n plain.hashRoot = this.hashRoot.toPlain();\r\n plain.hashCount = this.hashCount;\r\n plain.timeout = this.timeout;\r\n plain.totalAmount = this.totalAmount.toString();\r\n return plain;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof HashedTimeLockedContract\r\n && this._type === o._type\r\n && this._balance.eq(o._balance)\r\n && this._sender.equals(o._sender)\r\n && this._recipient.equals(o._recipient)\r\n && this._hashRoot.equals(o._hashRoot)\r\n && this._hashCount === o._hashCount\r\n && this._timeout === o._timeout\r\n && this._totalAmount.eq(o._totalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n try {\r\n const buf = new SerialBuffer(transaction.proof);\r\n const type = buf.readUint8();\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n let preImage = Hash.unserialize(buf, hashAlgorithm);\r\n\r\n // Verify that the preImage hashed hashDepth times matches the _provided_ hashRoot.\r\n for (let i = 0; i < hashDepth; ++i) {\r\n preImage = Hash.compute(preImage.array, hashAlgorithm);\r\n }\r\n if (!hashRoot.equals(preImage)) {\r\n return false;\r\n }\r\n\r\n // Signature proof of the HTLC recipient\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n // Signature proof of the HTLC recipient\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n\r\n // Signature proof of the HTLC creator\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE:\r\n // Signature proof of the HTLC creator\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n default:\r\n return false;\r\n }\r\n\r\n // Reject overlong proof.\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return true; // Accept\r\n } catch (e) {\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n try {\r\n const buf = new SerialBuffer(transaction.data);\r\n\r\n Address.unserialize(buf); // sender address\r\n Address.unserialize(buf); // recipient address\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8(); // hash count\r\n buf.readUint32(); // timeout\r\n\r\n if (hashCount === 0) {\r\n return false;\r\n }\r\n\r\n // Blacklist Argon2 hash function.\r\n if (hashAlgorithm === Hash.Algorithm.ARGON2D) {\r\n return false;\r\n }\r\n\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return Contract.verifyIncomingTransaction(transaction);\r\n } catch (e) {\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new HashedTimeLockedContract(balance, this._sender, this._recipient, this._hashRoot, this._hashCount, this._timeout, this._totalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account|*}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n const buf = new SerialBuffer(transaction.proof);\r\n const type = buf.readUint8();\r\n let minCap = 0;\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n // Check that the contract has not expired yet.\r\n if (this._timeout < blockHeight) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n // Check that the provided hashRoot is correct.\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n if (!hashRoot.equals(this._hashRoot)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n // Ignore the preImage.\r\n Hash.unserialize(buf, hashAlgorithm);\r\n\r\n // Verify that the transaction is signed by the authorized recipient.\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._recipient)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n minCap = BigNumber.max(0, this._totalAmount.times(1 - (hashDepth / this._hashCount)).idiv(1));\r\n\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._recipient)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._sender)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: {\r\n if (this._timeout >= blockHeight) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._sender)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n break;\r\n }\r\n default:\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!revert) {\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(minCap)) {\r\n throw new Account.BalanceError();\r\n }\r\n }\r\n\r\n return super.withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert);\r\n }\r\n\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n throw new Error('Illegal incoming transaction');\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n try {\r\n const buf = new SerialBuffer(data);\r\n\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n\r\n return {\r\n sender: sender.toPlain(),\r\n recipient: recipient.toPlain(),\r\n hashAlgorithm: Hash.Algorithm.toString(hashAlgorithm),\r\n hashRoot: hashRoot.toPlain(),\r\n hashCount,\r\n timeout\r\n };\r\n } catch (e) {\r\n return Account.dataToPlain(data);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const buf = new SerialBuffer(proof);\r\n const type = buf.readUint8();\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const preImage = Hash.unserialize(buf, hashAlgorithm);\r\n const signatureProof = SignatureProof.unserialize(buf);\r\n\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n hashAlgorithm: Hash.Algorithm.toString(hashAlgorithm),\r\n hashDepth,\r\n hashRoot: hashRoot.toPlain(),\r\n preImage: preImage.toPlain(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n const signatureProof = SignatureProof.unserialize(buf);\r\n const creatorSignatureProof = SignatureProof.unserialize(buf);\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n pathLength: signatureProof.merklePath.nodes.length,\r\n creator: creatorSignatureProof.publicKey.toAddress().toPlain(),\r\n creatorSignature: creatorSignatureProof.signature.toHex(),\r\n creatorPublicKey: creatorSignatureProof.publicKey.toHex(),\r\n creatorPathLength: creatorSignatureProof.merklePath.nodes.length\r\n };\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: {\r\n const creatorSignatureProof = SignatureProof.unserialize(buf);\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n creator: creatorSignatureProof.publicKey.toAddress().toPlain(),\r\n creatorSignature: creatorSignatureProof.signature.toHex(),\r\n creatorPublicKey: creatorSignatureProof.publicKey.toHex(),\r\n creatorPathLength: creatorSignatureProof.merklePath.nodes.length\r\n };\r\n }\r\n default:\r\n return false;\r\n }\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nHashedTimeLockedContract.ProofType = {\r\n REGULAR_TRANSFER: 1,\r\n EARLY_RESOLVE: 2,\r\n TIMEOUT_RESOLVE: 3\r\n};\r\n\r\n/**\r\n * @param {HashedTimeLockedContract.ProofType} proofType\r\n * @return {string}\r\n */\r\nHashedTimeLockedContract.ProofType.toString = function(proofType) {\r\n switch (proofType) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: return 'regular-transfer';\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: return 'early-resolve';\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: return 'timeout-resolve';\r\n }\r\n throw new Error('Invalid proof type');\r\n};\r\n\r\nAccount.TYPE_MAP.set(Account.Type.HTLC, HashedTimeLockedContract);\r\nClass.register(HashedTimeLockedContract);\r\n","class VestingContract extends Contract {\r\n /**\r\n * @param {BigNumber|number|string} [balance]\r\n * @param {Address} [owner]\r\n * @param {number} [vestingStart]\r\n * @param {number} [vestingStepBlocks]\r\n * @param {BigNumber|number|string} [vestingStepAmount]\r\n * @param {BigNumber|number|string} [vestingTotalAmount]\r\n */\r\n constructor(balance = 0, owner = Address.NULL, vestingStart = 0, vestingStepBlocks = 0, vestingStepAmount = balance, vestingTotalAmount = balance) {\r\n super(Account.Type.VESTING, balance);\r\n const bigVestingStepAmount = new BigNumber(vestingStepAmount);\r\n const bigVestingTotalAmount = new BigNumber(vestingTotalAmount);\r\n if (!(owner instanceof Address)) throw new Error('Malformed owner address');\r\n if (!NumberUtils.isUint32(vestingStart)) throw new Error('Malformed vestingStart');\r\n if (!NumberUtils.isUint32(vestingStepBlocks)) throw new Error('Malformed vestingStepBlocks');\r\n if (!NumberUtils.isUint128(bigVestingStepAmount)) throw new Error('Malformed vestingStepAmount');\r\n if (!NumberUtils.isUint128(bigVestingTotalAmount)) throw new Error('Malformed vestingTotalAmount');\r\n\r\n /** @type {Address} */\r\n this._owner = owner;\r\n /** @type {number} */\r\n this._vestingStart = vestingStart;\r\n /** @type {number} */\r\n this._vestingStepBlocks = vestingStepBlocks;\r\n /** @type {BigNumber} */\r\n this._vestingStepAmount = bigVestingStepAmount;\r\n /** @type {BigNumber} */\r\n this._vestingTotalAmount = bigVestingTotalAmount;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {number} blockHeight\r\n * @param {Transaction} transaction\r\n */\r\n static create(balance, blockHeight, transaction) {\r\n /** @type {number} */\r\n let vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount;\r\n const buf = new SerialBuffer(transaction.data);\r\n const owner = Address.unserialize(buf);\r\n vestingTotalAmount = transaction.value;\r\n switch (transaction.data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n // Only block number: vest full amount at that block\r\n vestingStart = 0;\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = vestingTotalAmount;\r\n break;\r\n case Address.SERIALIZED_SIZE + 24:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128();\r\n break;\r\n case Address.SERIALIZED_SIZE + 40:\r\n // Create a vesting account with some instantly vested funds or additional funds considered.\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128();\r\n vestingTotalAmount = buf.readUint128();\r\n break;\r\n default:\r\n throw new Error('Invalid transaction data');\r\n }\r\n return new VestingContract(balance, owner, vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {VestingContract}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.VESTING) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n const owner = Address.unserialize(buf);\r\n const vestingStart = buf.readUint32();\r\n const vestingStepBlocks = buf.readUint32();\r\n const vestingStepAmount = buf.readUint128();\r\n const vestingTotalAmount = buf.readUint128();\r\n return new VestingContract(balance, owner, vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid account');\r\n return new VestingContract(plain.balance, Address.fromAny(plain.owner), plain.vestingStart, plain.vestingStepBlocks, plain.vestingStepAmount, plain.vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * Serialize this VestingContract object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n super.serialize(buf);\r\n this._owner.serialize(buf);\r\n buf.writeUint32(this._vestingStart);\r\n buf.writeUint32(this._vestingStepBlocks);\r\n buf.writeUint128(this._vestingStepAmount);\r\n buf.writeUint128(this._vestingTotalAmount);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return super.serializedSize\r\n + this._owner.serializedSize\r\n + /*vestingStart*/ 4\r\n + /*vestingStepBlocks*/ 4\r\n + /*vestingStepAmount*/ 16\r\n + /*vestingTotalAmount*/ 16;\r\n }\r\n\r\n /** @type {Address} */\r\n get owner() {\r\n return this._owner;\r\n }\r\n\r\n /** @type {number} */\r\n get vestingStart() {\r\n return this._vestingStart;\r\n }\r\n\r\n /** @type {number} */\r\n get vestingStepBlocks() {\r\n return this._vestingStepBlocks;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get vestingStepAmount() {\r\n return this._vestingStepAmount;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get vestingTotalAmount() {\r\n return this._vestingTotalAmount;\r\n }\r\n\r\n toString() {\r\n return `VestingAccount{balance=${this._balance.toString()}, owner=${this._owner.toUserFriendlyAddress()}`;\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n const plain = super.toPlain();\r\n plain.owner = this.owner.toPlain();\r\n plain.vestingStart = this.vestingStart;\r\n plain.vestingStepBlocks = this.vestingStepBlocks;\r\n plain.vestingStepAmount = this.vestingStepAmount.toString();\r\n plain.vestingTotalAmount = this.vestingTotalAmount.toString();\r\n return plain;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof VestingContract\r\n && this._type === o._type\r\n && this._balance.eq(o._balance)\r\n && this._owner.equals(o._owner)\r\n && this._vestingStart === o._vestingStart\r\n && this._vestingStepBlocks === o._vestingStepBlocks\r\n && this._vestingStepAmount.eq(o._vestingStepAmount)\r\n && this._vestingTotalAmount.eq(o._vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n const buf = new SerialBuffer(transaction.proof);\r\n\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n switch (transaction.data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n case Address.SERIALIZED_SIZE + 24:\r\n case Address.SERIALIZED_SIZE + 40:\r\n return Contract.verifyIncomingTransaction(transaction);\r\n default:\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new VestingContract(balance, this._owner, this._vestingStart, this._vestingStepBlocks, this._vestingStepAmount, this._vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account|*}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n if (!revert) {\r\n const minCap = this.getMinCap(blockHeight);\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(minCap)) {\r\n throw new Account.BalanceError();\r\n }\r\n\r\n const buf = new SerialBuffer(transaction.proof);\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._owner)) {\r\n throw new Account.ProofError();\r\n }\r\n }\r\n return super.withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n throw new Error('Illegal incoming transaction');\r\n }\r\n\r\n /**\r\n * @param {number} blockHeight\r\n * @returns {number}\r\n */\r\n getMinCap(blockHeight) {\r\n return this._vestingStepBlocks && this._vestingStepAmount.gt(0)\r\n ? BigNumber.max(0, this._vestingTotalAmount.minus(this._vestingStepAmount.times(Math.floor((blockHeight - this._vestingStart) / this._vestingStepBlocks))))\r\n : new BigNumber(0);\r\n }\r\n\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n try {\r\n let vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount;\r\n const buf = new SerialBuffer(data);\r\n const owner = Address.unserialize(buf);\r\n switch (data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n vestingStart = 0;\r\n vestingStepBlocks = buf.readUint32();\r\n break;\r\n case Address.SERIALIZED_SIZE + 24:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128().toString();\r\n break;\r\n case Address.SERIALIZED_SIZE + 40:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128().toString();\r\n vestingTotalAmount = buf.readUint128().toString();\r\n break;\r\n default:\r\n throw new Error('Invalid transaction data');\r\n }\r\n return {\r\n owner: owner.toPlain(),\r\n vestingStart,\r\n vestingStepBlocks,\r\n vestingStepAmount,\r\n vestingTotalAmount\r\n };\r\n } catch (e) {\r\n return Account.dataToPlain(data);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const signatureProof = SignatureProof.unserialize(new SerialBuffer(proof));\r\n return {\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nAccount.TYPE_MAP.set(Account.Type.VESTING, VestingContract);\r\nClass.register(VestingContract);\r\n","/**\r\n * @abstract\r\n */\r\nclass Transaction {\r\n /**\r\n * @param {Transaction.Format} format\r\n * @param {Address} sender\r\n * @param {Account.Type} senderType\r\n * @param {Address} recipient\r\n * @param {Account.Type} recipientType\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Transaction.Flag | *} flags\r\n * @param {Uint8Array} data\r\n * @param {Uint8Array} [proof]\r\n * @param {number} [networkId]\r\n */\r\n constructor(format, sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId = GenesisConfig.NETWORK_ID) {\r\n const bigValue = new BigNumber(value);\r\n if (!(sender instanceof Address)) throw new Error('Malformed sender');\r\n if (!NumberUtils.isUint8(senderType)) throw new Error('Malformed sender type');\r\n if (!(recipient instanceof Address)) throw new Error('Malformed recipient');\r\n if (!NumberUtils.isUint8(recipientType)) throw new Error('Malformed recipient type');\r\n if (!NumberUtils.isUint128(bigValue) || bigValue.eq(0)) throw new Error('Malformed value');\r\n if (!NumberUtils.isUint32(validityStartHeight)) throw new Error('Malformed validityStartHeight');\r\n if (!NumberUtils.isUint8(flags) && (flags & ~(Transaction.Flag.ALL)) > 0) throw new Error('Malformed flags');\r\n if (!(data instanceof Uint8Array) || !(NumberUtils.isUint16(data.byteLength))) throw new Error('Malformed data');\r\n if (proof && (!(proof instanceof Uint8Array) || !(NumberUtils.isUint16(proof.byteLength)))) throw new Error('Malformed proof');\r\n if (!NumberUtils.isUint8(networkId)) throw new Error('Malformed networkId');\r\n\r\n /** @type {Transaction.Format} */\r\n this._format = format;\r\n /** @type {Address} */\r\n this._sender = sender;\r\n /** @type {Account.Type} */\r\n this._senderType = senderType;\r\n /** @type {Address} */\r\n this._recipient = recipient;\r\n /** @type {Account.Type} */\r\n this._recipientType = recipientType;\r\n /** @type {number} */\r\n this._value = bigValue;\r\n /** @type {number} */\r\n this._fee = Policy.txFee(validityStartHeight);\r\n /** @type {number} */\r\n this._networkId = networkId;\r\n /** @type {number} */\r\n this._validityStartHeight = validityStartHeight;\r\n /** @type {Transaction.Flag | *} */\r\n this._flags = flags;\r\n /** @type {Uint8Array} */\r\n this._data = data;\r\n /** @type {Uint8Array} */\r\n this._proof = proof;\r\n\r\n if (this._recipient === Address.CONTRACT_CREATION) this._recipient = this.getContractCreationAddress();\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const format = /** @type {Transaction.Format} */ buf.readUint8();\r\n buf.readPos--;\r\n\r\n if (!Transaction.FORMAT_MAP.has(format)) throw new Error('Invalid transaction type');\r\n return Transaction.FORMAT_MAP.get(format).unserialize(buf);\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serializeContent(buf) {\r\n buf = buf || new SerialBuffer(this.serializedContentSize);\r\n buf.writeUint16(this._data.byteLength);\r\n buf.write(this._data);\r\n this._sender.serialize(buf);\r\n buf.writeUint8(this._senderType);\r\n this._recipient.serialize(buf);\r\n buf.writeUint8(this._recipientType);\r\n buf.writeUint128(this._value);\r\n buf.writeUint128(this._fee);\r\n buf.writeUint32(this._validityStartHeight);\r\n buf.writeUint8(this._networkId);\r\n buf.writeUint8(this._flags);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedContentSize() {\r\n return /*dataSize*/ 2\r\n + this._data.byteLength\r\n + this._sender.serializedSize\r\n + /*senderType*/ 1\r\n + this._recipient.serializedSize\r\n + /*recipientType*/ 1\r\n + /*value*/ 16\r\n + /*fee*/ 16\r\n + /*validityStartHeight*/ 4\r\n + /*networkId*/ 1\r\n + /*flags*/ 1;\r\n }\r\n\r\n /**\r\n * @param {number} [networkId]\r\n * @returns {boolean}\r\n */\r\n verify(networkId) {\r\n if (this._valid === undefined) {\r\n this._valid = this._verify(networkId);\r\n }\r\n return this._valid;\r\n }\r\n\r\n /**\r\n * @param {number} [networkId]\r\n * @returns {boolean}\r\n * @private\r\n */\r\n _verify(networkId = GenesisConfig.NETWORK_ID) {\r\n if (this._networkId !== networkId) {\r\n Log.w(Transaction, 'Transaction is not valid in this network', this);\r\n return false;\r\n }\r\n // Check that sender != recipient.\r\n if (this._recipient.equals(this._sender)) {\r\n Log.w(Transaction, 'Sender and recipient must not match', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.has(this._senderType) || !Account.TYPE_MAP.has(this._recipientType)) {\r\n Log.w(Transaction, 'Invalid account type', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.get(this._senderType).verifyOutgoingTransaction(this)) {\r\n Log.w(Transaction, 'Invalid for sender', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.get(this._recipientType).verifyIncomingTransaction(this)) {\r\n Log.w(Transaction, 'Invalid for recipient', this);\r\n return false;\r\n }\r\n if (!this._fee.eq(Policy.txFee(this._validityStartHeight))) {\r\n Log.w(Transaction, 'Invalid for tx fee', this);\r\n return false;\r\n }\r\n return true;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n throw new Error('Getter needs to be overwritten by subclasses');\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n throw new Error('Method needs to be overwritten by subclasses');\r\n }\r\n\r\n /**\r\n * @return {Hash}\r\n */\r\n hash() {\r\n // Exclude the signature, we don't want transactions to be malleable.\r\n this._hash = this._hash || Hash.light(this.serializeContent());\r\n return this._hash;\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {number}\r\n */\r\n compare(o) {\r\n if (this.fee.div(this.serializedSize).gt(o.fee.div(o.serializedSize))) return -1;\r\n if (this.fee.div(this.serializedSize).lt(o.fee.div(o.serializedSize))) return 1;\r\n if (this.serializedSize > o.serializedSize) return -1;\r\n if (this.serializedSize < o.serializedSize) return 1;\r\n if (this.fee.gt(o.fee)) return -1;\r\n if (this.fee.lt(o.fee)) return 1;\r\n if (this.value.gt(o.value)) return -1;\r\n if (this.value.lt(o.value)) return 1;\r\n return this.compareBlockOrder(o);\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {number}\r\n */\r\n compareBlockOrder(o) {\r\n // This function must return 0 iff this.equals(o).\r\n const recCompare = this._recipient.compare(o._recipient);\r\n if (recCompare !== 0) return recCompare;\r\n if (this._validityStartHeight < o._validityStartHeight) return -1;\r\n if (this._validityStartHeight > o._validityStartHeight) return 1;\r\n if (this._fee.gt(o._fee)) return -1;\r\n if (this._fee.lt(o._fee)) return 1;\r\n if (this._value.gt(o._value)) return -1;\r\n if (this._value.lt(o._value)) return 1;\r\n const senderCompare = this._sender.compare(o._sender);\r\n if (senderCompare !== 0) return senderCompare;\r\n if (this._recipientType < o._recipientType) return -1;\r\n if (this._recipientType > o._recipientType) return 1;\r\n if (this._senderType < o._senderType) return -1;\r\n if (this._senderType > o._senderType) return 1;\r\n if (this._flags < o._flags) return -1;\r\n if (this._flags > o._flags) return 1;\r\n return BufferUtils.compare(this._data, o._data);\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n // This ignores format and proof to be consistent with hash():\r\n // tx1.hash() == tx2.hash() iff tx1.equals(t2)\r\n return o instanceof Transaction\r\n && this._sender.equals(o._sender)\r\n && this._senderType === o._senderType\r\n && this._recipient.equals(o._recipient)\r\n && this._recipientType === o._recipientType\r\n && this._value.eq(o._value)\r\n && this._fee.eq(o._fee)\r\n && this._validityStartHeight === o._validityStartHeight\r\n && this._networkId === o._networkId\r\n && this._flags === o._flags\r\n && BufferUtils.equals(this._data, o._data);\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toString() {\r\n return `Transaction{`\r\n + `sender=${this._sender.toHex()}, `\r\n + `recipient=${this._recipient.toHex()}, `\r\n + `value=${this._value.toString()}, `\r\n + `fee=${this._fee.toString()}, `\r\n + `validityStartHeight=${this._validityStartHeight}, `\r\n + `networkId=${this._networkId}`\r\n + `}`;\r\n }\r\n\r\n toPlain() {\r\n const data = Account.TYPE_MAP.get(this.recipientType).dataToPlain(this.data);\r\n data.raw = BufferUtils.toHex(this.data);\r\n const proof = Account.TYPE_MAP.get(this.senderType).proofToPlain(this.proof);\r\n proof.raw = BufferUtils.toHex(this.proof);\r\n return {\r\n transactionHash: this.hash().toPlain(),\r\n format: Transaction.Format.toString(this._format),\r\n sender: this.sender.toPlain(),\r\n senderType: Account.Type.toString(this.senderType),\r\n recipient: this.recipient.toPlain(),\r\n recipientType: Account.Type.toString(this.recipientType),\r\n value: this.value.toString(),\r\n fee: this.fee.toString(),\r\n feePerByte: this.feePerByte.toString(),\r\n validityStartHeight: this.validityStartHeight,\r\n network: GenesisConfig.networkIdToNetworkName(this.networkId),\r\n flags: this.flags,\r\n data,\r\n proof,\r\n size: this.serializedSize,\r\n valid: this.verify()\r\n };\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {Transaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n const format = Transaction.Format.fromAny(plain.format);\r\n if (!Transaction.FORMAT_MAP.has(format)) throw new Error('Invalid transaction type');\r\n return Transaction.FORMAT_MAP.get(format).fromPlain(plain);\r\n }\r\n\r\n /**\r\n * @param {Transaction|string|object} tx\r\n * @returns {Transaction}\r\n */\r\n static fromAny(tx) {\r\n if (tx instanceof Transaction) return tx;\r\n if (typeof tx === 'object') return Transaction.fromPlain(tx);\r\n if (typeof tx === 'string') return Transaction.unserialize(new SerialBuffer(BufferUtils.fromHex(tx)));\r\n throw new Error('Invalid transaction format');\r\n }\r\n\r\n /**\r\n * @return {Address}\r\n */\r\n getContractCreationAddress() {\r\n const tx = Transaction.unserialize(this.serialize());\r\n tx._recipient = Address.NULL;\r\n tx._hash = null;\r\n return Address.fromHash(tx.hash());\r\n }\r\n\r\n /** @type {Transaction.Format} */\r\n get format() {\r\n return this._format;\r\n }\r\n\r\n /** @type {Address} */\r\n get sender() {\r\n return this._sender;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get senderType() {\r\n return this._senderType;\r\n }\r\n\r\n /** @type {Address} */\r\n get recipient() {\r\n return this._recipient;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get recipientType() {\r\n return this._recipientType;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get value() {\r\n return this._value;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get fee() {\r\n return this._fee;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get feePerByte() {\r\n return this._fee.div(this.serializedSize);\r\n }\r\n\r\n /** @type {number} */\r\n get networkId() {\r\n return this._networkId;\r\n }\r\n\r\n /** @type {number} */\r\n get validityStartHeight() {\r\n return this._validityStartHeight;\r\n }\r\n\r\n /** @type {number} */\r\n get flags() {\r\n return this._flags;\r\n }\r\n\r\n /**\r\n * @param {Transaction.Flag} flag\r\n * @returns {boolean}\r\n */\r\n hasFlag(flag) {\r\n return (this._flags & flag) > 0;\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get data() {\r\n return this._data;\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get proof() {\r\n return this._proof;\r\n }\r\n\r\n // Sender proof is set by the Wallet after signing a transaction.\r\n /** @type {Uint8Array} */\r\n set proof(proof) {\r\n this._proof = proof;\r\n }\r\n}\r\n\r\n/**\r\n * Enum for Transaction formats.\r\n * @enum\r\n */\r\nTransaction.Format = {\r\n BASIC: 0,\r\n EXTENDED: 1\r\n};\r\n/**\r\n * @param {Transaction.Format} format\r\n */\r\nTransaction.Format.toString = function(format) {\r\n switch (format) {\r\n case Transaction.Format.BASIC: return 'basic';\r\n case Transaction.Format.EXTENDED: return 'extended';\r\n }\r\n throw new Error('Invalid transaction format');\r\n};\r\n/**\r\n * @param {Transaction.Format|string} format\r\n * @return {Transaction.Format}\r\n */\r\nTransaction.Format.fromAny = function(format) {\r\n if (typeof format === 'number') return format;\r\n switch (format) {\r\n case 'basic': return Transaction.Format.BASIC;\r\n case 'extended': return Transaction.Format.EXTENDED;\r\n }\r\n throw new Error('Invalid transaction format');\r\n};\r\n/**\r\n * @enum\r\n */\r\nTransaction.Flag = {\r\n NONE: 0,\r\n CONTRACT_CREATION: 0b1,\r\n ALL: 0b1\r\n};\r\n/** @type {Map.<Transaction.Format, {unserialize: function(buf: SerialBuffer):Transaction, fromPlain: function(plain:object):Transaction}>} */\r\nTransaction.FORMAT_MAP = new Map();\r\n\r\nClass.register(Transaction);\r\n","class SignatureProof {\r\n /**\r\n * @param {Transaction} transaction\r\n * @returns {boolean}\r\n */\r\n static verifyTransaction(transaction) {\r\n try {\r\n const buffer = new SerialBuffer(transaction.proof);\r\n const proof = SignatureProof.unserialize(buffer);\r\n\r\n // Reject proof if it is longer than needed.\r\n if (buffer.readPos !== buffer.byteLength) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - overlong');\r\n return false;\r\n }\r\n\r\n return proof.verify(transaction.sender, transaction.serializeContent());\r\n } catch (e) {\r\n Log.w(SignatureProof, `Failed to verify transaction: ${e.message || e}`);\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {Signature} signature\r\n * @returns {SignatureProof}\r\n */\r\n static singleSig(publicKey, signature) {\r\n return new SignatureProof(publicKey, new MerklePath([]), signature);\r\n }\r\n\r\n /**\r\n * @param {PublicKey} signerKey\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @param {Signature} signature\r\n * @returns {SignatureProof}\r\n */\r\n static multiSig(signerKey, publicKeys, signature) {\r\n const merklePath = MerklePath.compute(publicKeys, signerKey);\r\n return new SignatureProof(signerKey, merklePath, signature);\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {MerklePath} merklePath\r\n * @param {Signature} signature\r\n */\r\n constructor(publicKey, merklePath, signature) {\r\n if (!(publicKey instanceof PublicKey)) throw new Error('Malformed publickKey');\r\n if (!(merklePath instanceof MerklePath)) throw new Error('Malformed merklePath');\r\n if (signature && !(signature instanceof Signature)) throw new Error('Malformed signature');\r\n\r\n /**\r\n * @type {PublicKey}\r\n * @private\r\n */\r\n this._publicKey = publicKey;\r\n /**\r\n * @type {MerklePath}\r\n * @private\r\n */\r\n this._merklePath = merklePath;\r\n /**\r\n * @type {Signature}\r\n * @private\r\n */\r\n this._signature = signature;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {SignatureProof}\r\n */\r\n static unserialize(buf) {\r\n const publicKey = PublicKey.unserialize(buf);\r\n const merklePath = MerklePath.unserialize(buf);\r\n const signature = Signature.unserialize(buf);\r\n return new SignatureProof(publicKey, merklePath, signature);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._publicKey.serialize(buf);\r\n this._merklePath.serialize(buf);\r\n\r\n // The SignatureProof is sometimes serialized before the signature is set (e.g. when creating transactions).\r\n // Simply don't serialize the signature if it's missing as this should never go over the wire.\r\n // We always expect the signature to be present when unserializing.\r\n if (this._signature) {\r\n this._signature.serialize(buf);\r\n }\r\n\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this._publicKey.serializedSize\r\n + this._merklePath.serializedSize\r\n + (this._signature ? this._signature.serializedSize : 0);\r\n }\r\n \r\n static get SINGLE_SIG_SIZE() {\r\n return PublicKey.SIZE + new MerklePath([]).serializedSize + Signature.SIZE;\r\n }\r\n\r\n /**\r\n * @param {SignatureProof} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof SignatureProof\r\n && this._publicKey.equals(o._publicKey)\r\n && this._merklePath.equals(o._merklePath)\r\n && (this._signature ? this._signature.equals(o._signature) : this._signature === o._signature);\r\n }\r\n\r\n /**\r\n * @param {?Address} sender\r\n * @param {Uint8Array} data\r\n * @returns {boolean}\r\n */\r\n verify(sender, data) {\r\n if (sender !== null && !this.isSignedBy(sender)) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signer does not match sender address');\r\n return false;\r\n }\r\n\r\n if (!this._signature) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signature is missing');\r\n return false;\r\n }\r\n\r\n if (!this._signature.verify(this._publicKey, data)) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signature is invalid');\r\n return false;\r\n }\r\n\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Address} sender\r\n * @returns {boolean}\r\n */\r\n isSignedBy(sender) {\r\n const merkleRoot = this._merklePath.computeRoot(this._publicKey);\r\n const signerAddr = Address.fromHash(merkleRoot);\r\n return signerAddr.equals(sender);\r\n }\r\n\r\n /** @type {PublicKey} */\r\n get publicKey() {\r\n return this._publicKey;\r\n }\r\n\r\n /** @type {MerklePath} */\r\n get merklePath() {\r\n return this._merklePath;\r\n }\r\n\r\n /** @type {Signature} */\r\n get signature() {\r\n return this._signature;\r\n }\r\n\r\n /** @type {Signature} */\r\n set signature(signature) {\r\n this._signature = signature;\r\n }\r\n}\r\n\r\nClass.register(SignatureProof);\r\n","class BasicTransaction extends Transaction {\r\n /**\r\n * @param {PublicKey} senderPubKey\r\n * @param {Address} recipient\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Signature} [signature]\r\n * @param {number} [networkId]\r\n */\r\n constructor(senderPubKey, recipient, value, validityStartHeight, signature, networkId) {\r\n if (!(senderPubKey instanceof PublicKey)) throw new Error('Malformed senderPubKey');\r\n // Signature may be initially empty and can be set later.\r\n if (signature !== undefined && !(signature instanceof Signature)) throw new Error('Malformed signature');\r\n\r\n const proof = SignatureProof.singleSig(senderPubKey, signature);\r\n super(Transaction.Format.BASIC, senderPubKey.toAddress(), Account.Type.BASIC, recipient, Account.Type.BASIC, value, validityStartHeight, Transaction.Flag.NONE, new Uint8Array(0), proof.serialize(), networkId);\r\n\r\n /**\r\n * @type {SignatureProof}\r\n * @private\r\n */\r\n this._signatureProof = proof;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n Assert.that(type === Transaction.Format.BASIC);\r\n\r\n const senderPubKey = PublicKey.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const value = buf.readUint128();\r\n const fee = buf.readUint128();\r\n const validityStartHeight = buf.readUint32();\r\n const networkId = buf.readUint8();\r\n const signature = Signature.unserialize(buf);\r\n return new BasicTransaction(senderPubKey, recipient, value, validityStartHeight, signature, networkId);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {BasicTransaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n return new BasicTransaction(\r\n PublicKey.fromAny(plain.proof.publicKey || plain.senderPubKey),\r\n Address.fromAny(plain.recipient),\r\n plain.value,\r\n plain.validityStartHeight,\r\n Signature.fromAny(plain.proof.signature || plain.signature),\r\n GenesisConfig.networkIdFromAny(plain.network || plain.networkId)\r\n );\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(Transaction.Format.BASIC);\r\n this.senderPubKey.serialize(buf);\r\n this._recipient.serialize(buf);\r\n buf.writeUint128(this._value);\r\n buf.writeUint128(this._fee);\r\n buf.writeUint32(this._validityStartHeight);\r\n buf.writeUint8(this._networkId);\r\n this.signature.serialize(buf);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + this.senderPubKey.serializedSize\r\n + this._recipient.serializedSize\r\n + /*value*/ 16\r\n + /*fee*/ 16\r\n + /*validityStartHeight*/ 4\r\n + /*networkId*/ 1\r\n + this.signature.serializedSize;\r\n }\r\n\r\n /**\r\n * @type {PublicKey}\r\n */\r\n get senderPubKey() {\r\n return this._signatureProof.publicKey;\r\n }\r\n\r\n /**\r\n * @type {Signature}\r\n */\r\n get signature() {\r\n return this._signatureProof.signature;\r\n }\r\n\r\n /**\r\n * @type {Signature}\r\n */\r\n set signature(signature) {\r\n this._signatureProof.signature = signature;\r\n this._proof = this._signatureProof.serialize();\r\n }\r\n}\r\nTransaction.FORMAT_MAP.set(Transaction.Format.BASIC, BasicTransaction);\r\nClass.register(BasicTransaction);\r\n","class ExtendedTransaction extends Transaction {\r\n\r\n /**\r\n * @param {Address} sender\r\n * @param {Account.Type} senderType\r\n * @param {Address} recipient\r\n * @param {Account.Type} recipientType\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Transaction.Flag | *} flags\r\n * @param {Uint8Array} data\r\n * @param {Uint8Array} [proof]\r\n * @param {number} [networkId]\r\n */\r\n constructor(sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof = new Uint8Array(0), networkId) {\r\n super(Transaction.Format.EXTENDED, sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const type = /** @type {Transaction.Format} */ buf.readUint8();\r\n Assert.that(type === Transaction.Format.EXTENDED);\r\n\r\n const dataSize = buf.readUint16();\r\n const data = buf.read(dataSize);\r\n const sender = Address.unserialize(buf);\r\n const senderType = /** @type {Account.Type} */ buf.readUint8();\r\n const recipient = Address.unserialize(buf);\r\n const recipientType = /** @type {Account.Type} */ buf.readUint8();\r\n const value = buf.readUint128();\r\n const fee = buf.readUint128();\r\n const validityStartHeight = buf.readUint32();\r\n const networkId = buf.readUint8();\r\n const flags = buf.readUint8();\r\n const proofSize = buf.readUint16();\r\n const proof = buf.read(proofSize);\r\n return new ExtendedTransaction(sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {ExtendedTransaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n return new ExtendedTransaction(\r\n Address.fromAny(plain.sender),\r\n Account.Type.fromAny(plain.senderType),\r\n Address.fromAny(plain.recipient),\r\n Account.Type.fromAny(plain.recipientType),\r\n plain.value,\r\n plain.validityStartHeight,\r\n plain.flags,\r\n BufferUtils.fromAny(plain.data.raw === undefined ? plain.data : plain.data.raw),\r\n BufferUtils.fromAny(plain.proof.raw === undefined ? plain.proof : plain.proof.raw),\r\n GenesisConfig.networkIdFromAny(plain.network || plain.networkId)\r\n );\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(Transaction.Format.EXTENDED);\r\n this.serializeContent(buf);\r\n buf.writeUint16(this._proof.byteLength);\r\n buf.write(this._proof);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + this.serializedContentSize\r\n + /*proofSize*/ 2\r\n + this._proof.byteLength;\r\n }\r\n}\r\n\r\nTransaction.FORMAT_MAP.set(Transaction.Format.EXTENDED, ExtendedTransaction);\r\nClass.register(ExtendedTransaction);\r\n","/**\r\n * @interface\r\n */\r\nclass IWorker {\r\n static async createProxy(clazz, name, worker) {\r\n return new (IWorker.Proxy(clazz))(worker, name);\r\n }\r\n\r\n static async startWorkerForProxy(clazz, name, workerScript) {\r\n if (!IWorker._workersSupported) {\r\n await IWorker._workerImplementation[clazz.name].init(name);\r\n return IWorker._workerImplementation[clazz.name];\r\n } else {\r\n if (!workerScript) {\r\n workerScript = `${Krypton._path}worker.js`;\r\n }\r\n return IWorker.createProxy(clazz, name, new Worker(URL.createObjectURL(new Blob([`Krypton = {_path: '${Krypton._path}'}; importScripts('${workerScript.replace(/'/g, '')}');`]))));\r\n }\r\n }\r\n\r\n static async startWorkerPoolForProxy(clazz, name, size, workerScript) {\r\n return (new (IWorker.Pool(clazz))((name) => IWorker.startWorkerForProxy(clazz, name, workerScript), name, size)).start();\r\n }\r\n\r\n static async stubBaseOnMessage(msg) {\r\n try {\r\n if (msg.data.command === 'init') {\r\n if (IWorker._workerImplementation[msg.data.args[0]]) {\r\n const res = await IWorker._workerImplementation[msg.data.args[0]].init(msg.data.args[1]);\r\n self.postMessage({status: 'OK', result: res, id: msg.data.id});\r\n } else {\r\n self.postMessage({status: 'error', result: 'Unknown worker!', id: msg.data.id});\r\n }\r\n } else {\r\n self.postMessage({status: 'error', result: 'Worker not yet initialized!', id: msg.data.id});\r\n }\r\n } catch (e) {\r\n self.postMessage({status: 'error', result: e, id: msg.data.id});\r\n }\r\n }\r\n\r\n static get _workersSupported() {\r\n return typeof Worker !== 'undefined';\r\n }\r\n\r\n static get areWorkersAsync() {\r\n return IWorker._workersSupported;\r\n }\r\n\r\n static get _insideWebWorker() {\r\n return typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;\r\n }\r\n\r\n static get _global() {\r\n return typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : null;\r\n }\r\n\r\n static prepareForWorkerUse(baseClazz, impl) {\r\n if (IWorker._insideWebWorker) {\r\n // Only inside WebWorker\r\n self.onmessage = IWorker.stubBaseOnMessage;\r\n }\r\n IWorker._workerImplementation = IWorker._workerImplementation || {};\r\n IWorker._workerImplementation[baseClazz.name] = impl;\r\n }\r\n\r\n static _loadBrowserScript(url, resolve) {\r\n // Adding the script tag to the head as suggested before\r\n const head = document.getElementsByTagName('head')[0];\r\n const script = document.createElement('script');\r\n script.type = 'text/javascript';\r\n script.src = url;\r\n\r\n // Then bind the event to the callback function.\r\n // There are several events for cross browser compatibility.\r\n // These events might occur before processing, so delay them a bit.\r\n const ret = () => setTimeout(resolve, 100);\r\n script.onreadystatechange = ret;\r\n script.onload = ret;\r\n\r\n // Fire the loading\r\n head.appendChild(script);\r\n }\r\n\r\n static Proxy(clazz) {\r\n const proxyClass = class extends clazz {\r\n /**\r\n * @param {Worker} worker\r\n * @param {string} [name]\r\n */\r\n constructor(worker, name) {\r\n super();\r\n this._name = name;\r\n this._messageId = 0;\r\n this._worker = worker;\r\n this._worker.onmessage = this._receive.bind(this);\r\n /** @type {Map.<number,{resolve:Function,error:Function}>} */\r\n this._waiting = new Map();\r\n return this._invoke('init', [clazz.name, name]).then(() => { return this; });\r\n }\r\n\r\n _receive(msg) {\r\n const cb = this._waiting.get(msg.data.id);\r\n if (!cb) {\r\n Log.w(WorkerProxy, 'Unknown reply', msg);\r\n } else {\r\n this._waiting.delete(msg.data.id);\r\n if (msg.data.status === 'OK') {\r\n cb.resolve(msg.data.result);\r\n } else if (msg.data.status === 'error') {\r\n cb.error(msg.data.result);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {string} command\r\n * @param {object[]} [args]\r\n * @returns {Promise}\r\n * @private\r\n */\r\n _invoke(command, args = []) {\r\n return new Promise((resolve, error) => {\r\n const obj = {command: command, args: args, id: this._messageId++};\r\n this._waiting.set(obj.id, {resolve, error});\r\n this._worker.postMessage(obj);\r\n });\r\n }\r\n\r\n destroy() {\r\n return this._invoke('destroy');\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n proxyClass.prototype[funcName] = function (...args) {\r\n return this._invoke(funcName, args);\r\n };\r\n }\r\n }\r\n return proxyClass;\r\n }\r\n\r\n /**\r\n * @param {object} clazz\r\n * @return {Stub}\r\n * @constructor\r\n */\r\n static Stub(clazz) {\r\n const Stub = class extends clazz {\r\n constructor() {\r\n super();\r\n }\r\n\r\n _result(msg, status, result) {\r\n self.postMessage({status, result, id: msg.data.id});\r\n }\r\n\r\n _onmessage(msg) {\r\n try {\r\n const res = this._invoke(msg.data.command, msg.data.args);\r\n if (res instanceof Promise) {\r\n res.then((finalRes) => { this._result(msg, 'OK', finalRes); });\r\n } else {\r\n this._result(msg, 'OK', res);\r\n }\r\n } catch (e) {\r\n this._result(msg, 'error', e.message || e);\r\n }\r\n }\r\n\r\n init(name) {\r\n this._name = name;\r\n if (IWorker._insideWebWorker) {\r\n self.name = name;\r\n self.onmessage = (msg) => this._onmessage(msg);\r\n }\r\n }\r\n\r\n _invoke(command, args) {\r\n return this[command].apply(this, args);\r\n }\r\n\r\n destroy() {\r\n if (IWorker._insideWebWorker) {\r\n self.close();\r\n }\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n Stub.prototype[funcName] = function () {\r\n throw `Not implemented in IWorker Stub: ${funcName}`;\r\n };\r\n }\r\n }\r\n return Stub;\r\n }\r\n\r\n static Pool(clazz) {\r\n const poolClass = class extends clazz {\r\n /**\r\n *\r\n * @param {function(string):Promise} proxyInitializer\r\n * @param {string} [name]\r\n * @param {number} [size] Number of workers in this pool.\r\n */\r\n constructor(proxyInitializer, name = 'pool', size = 1) {\r\n super();\r\n /** @type {function(string):Promise} */\r\n this._proxyInitializer = proxyInitializer;\r\n /** @type {string} */\r\n this._name = name;\r\n /** @type {number} */\r\n this._poolSize = size;\r\n /** @type {Array} */\r\n this._workers = [];\r\n /** @type {Array} */\r\n this._freeWorkers = [];\r\n /** @type {Array.<{name:string, args:Array, resolve:function, error:function}>} */\r\n this._waitingCalls = [];\r\n }\r\n\r\n async start() {\r\n await this._updateToSize();\r\n\r\n return this;\r\n }\r\n\r\n get poolSize() {\r\n return this._poolSize;\r\n }\r\n\r\n set poolSize(_size) {\r\n this._poolSize = _size;\r\n this._updateToSize().catch(Log.w.tag(IWorker));\r\n }\r\n\r\n destroy() {\r\n this._poolSize = 0;\r\n return this._updateToSize();\r\n }\r\n\r\n /**\r\n * @param {string} name Name of the function to call on a worker\r\n * @param {Array} args Arguments to pass to the function\r\n * @returns {Promise}\r\n */\r\n _invoke(name, args) {\r\n if (IWorker._workersSupported) {\r\n return new Promise((resolve, error) => {\r\n this._waitingCalls.push({name, args, resolve, error});\r\n const worker = this._freeWorkers.shift();\r\n if (worker) {\r\n this._step(worker).catch(Log.w.tag(IWorker));\r\n }\r\n });\r\n } else {\r\n return this._workers[0][name].apply(this._workers[0], args);\r\n }\r\n }\r\n\r\n /**\r\n * @param worker\r\n * @returns {Promise.<void>}\r\n * @private\r\n */\r\n async _step(worker) {\r\n let call = this._waitingCalls.shift();\r\n while (call) {\r\n try {\r\n // eslint-disable-next-line no-await-in-loop\r\n call.resolve(await worker[call.name].apply(worker, call.args));\r\n } catch (e) {\r\n call.error(e);\r\n }\r\n if (this._workers.indexOf(worker) === -1) {\r\n worker.destroy();\r\n return;\r\n }\r\n call = this._waitingCalls.shift();\r\n }\r\n this._freeWorkers.push(worker);\r\n }\r\n\r\n async _updateToSize() {\r\n if (typeof Worker === 'undefined' && this._poolSize > 1) {\r\n Log.d(IWorker, 'Pool of size larger than 1 requires WebWorker support.');\r\n this._poolSize = 1;\r\n }\r\n\r\n const workerPromises = [];\r\n while (this._workers.length + workerPromises.length < this._poolSize) {\r\n workerPromises.push(this._proxyInitializer(`${this._name}#${this._workers.length + workerPromises.length}`));\r\n }\r\n const createdWorkers = await Promise.all(workerPromises);\r\n for (const worker of createdWorkers) {\r\n this._workers.push(worker);\r\n this._step(worker).catch(Log.w.tag(IWorker));\r\n }\r\n\r\n while (this._workers.length > this._poolSize) {\r\n const worker = this._freeWorkers.shift() || this._workers.pop();\r\n const idx = this._workers.indexOf(worker);\r\n if (idx >= 0) {\r\n // This was a free worker, also remove it from the worker list and destroy it now.\r\n this._workers.splice(idx, 1);\r\n worker.destroy();\r\n }\r\n }\r\n return this;\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n poolClass.prototype[funcName] = function (...args) {\r\n return this._invoke(funcName, args);\r\n };\r\n }\r\n }\r\n return poolClass;\r\n }\r\n}\r\n\r\nIWorker._moduleLoadedCallbacks = {};\r\nIWorker._workerImplementation = {};\r\nClass.register(IWorker);\r\n","/**\r\n * @interface\r\n */\r\nclass CryptoWorker {\r\n static get lib() { return CryptoLib.instance; }\r\n\r\n /**\r\n * @returns {Promise.<CryptoWorker>}\r\n */\r\n static async getInstanceAsync() {\r\n if (!CryptoWorker._workerAsync) {\r\n CryptoWorker._workerAsync = await IWorker.startWorkerPoolForProxy(CryptoWorker, 'crypto', 4);\r\n }\r\n return CryptoWorker._workerAsync;\r\n }\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Promise.<Uint8Array>}\r\n */\r\n async computeArgon2d(input) {}\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} inputs\r\n * @returns {Promise.<Array.<Uint8Array>>}\r\n */\r\n async computeArgon2dBatch(inputs) {}\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Promise.<Uint8Array>}\r\n * @deprecated\r\n */\r\n async kdfLegacy(key, salt, iterations, outputSize) {}\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Promise.<Uint8Array>}\r\n */\r\n async kdf(key, salt, iterations, outputSize) {}\r\n\r\n /**\r\n * @param {Uint8Array} block\r\n * @param {Array.<bool>} transactionValid\r\n * @param {number} timeNow\r\n * @param {Uint8Array} genesisHash\r\n * @param {number} networkId\r\n * @returns {Promise.<{valid: boolean, pow: SerialBuffer, interlinkHash: SerialBuffer, bodyHash: SerialBuffer}>}\r\n */\r\n async blockVerify(block, transactionValid, timeNow, genesisHash, networkId) {}\r\n}\r\n/** @type {CryptoWorker} */\r\nCryptoWorker._workerAsync = null;\r\n\r\nClass.register(CryptoWorker);\r\n","class CryptoUtils {\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} data\r\n * @return {Uint8Array}\r\n */\r\n static computeHmacSha512(key, data) {\r\n if (key.length > CryptoUtils.SHA512_BLOCK_SIZE) {\r\n key = new SerialBuffer(Hash.computeSha512(key));\r\n }\r\n\r\n const iKey = new SerialBuffer(CryptoUtils.SHA512_BLOCK_SIZE);\r\n const oKey = new SerialBuffer(CryptoUtils.SHA512_BLOCK_SIZE);\r\n for (let i = 0; i < CryptoUtils.SHA512_BLOCK_SIZE; ++i) {\r\n const byte = key[i] || 0;\r\n iKey[i] = 0x36 ^ byte;\r\n oKey[i] = 0x5c ^ byte;\r\n }\r\n\r\n const innerHash = Hash.computeSha512(BufferUtils.concatTypedArrays(iKey, data));\r\n return Hash.computeSha512(BufferUtils.concatTypedArrays(oKey, innerHash));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} password\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} derivedKeyLength\r\n * @return {SerialBuffer}\r\n */\r\n static computePBKDF2sha512(password, salt, iterations, derivedKeyLength) {\r\n // Following https://www.ietf.org/rfc/rfc2898.txt\r\n const hashLength = Hash.SIZE.get(Hash.Algorithm.SHA512);\r\n\r\n if (derivedKeyLength > (Math.pow(2, 32) - 1) * hashLength) {\r\n throw new Error('Derived key too long');\r\n }\r\n\r\n const l = Math.ceil(derivedKeyLength / hashLength);\r\n const r = derivedKeyLength - (l - 1) * hashLength;\r\n\r\n const derivedKey = new SerialBuffer(derivedKeyLength);\r\n for (let i = 1; i <= l; i++) {\r\n let u = new SerialBuffer(salt.length + 4);\r\n u.write(salt);\r\n u.writeUint32(i);\r\n\r\n u = CryptoUtils.computeHmacSha512(password, u);\r\n const t = u;\r\n for (let j = 1; j < iterations; j++) {\r\n u = CryptoUtils.computeHmacSha512(password, u);\r\n for (let k = 0; k < t.length; k++) {\r\n t[k] ^= u[k];\r\n }\r\n }\r\n\r\n if (i < l) {\r\n derivedKey.write(t);\r\n } else {\r\n derivedKey.write(t.slice(0, r));\r\n }\r\n }\r\n return derivedKey;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @return {Promise.<Uint8Array>}\r\n * @deprecated\r\n */\r\n static async otpKdfLegacy(message, key, salt, iterations) {\r\n const worker = await CryptoWorker.getInstanceAsync();\r\n const derivedKey = await worker.kdfLegacy(key, salt, iterations, message.byteLength);\r\n return BufferUtils.xor(message, derivedKey);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @return {Promise.<Uint8Array>}\r\n */\r\n static async otpKdf(message, key, salt, iterations) {\r\n const worker = await CryptoWorker.getInstanceAsync();\r\n const derivedKey = await worker.kdf(key, salt, iterations, message.byteLength);\r\n return BufferUtils.xor(message, derivedKey);\r\n }\r\n\r\n}\r\nCryptoUtils.SHA512_BLOCK_SIZE = 128;\r\n\r\nClass.register(CryptoUtils);\r\n","class GenesisConfig {\r\n static main() {\r\n GenesisConfig.init(GenesisConfig.CONFIGS['main']);\r\n }\r\n\r\n static test() {\r\n GenesisConfig.init(GenesisConfig.CONFIGS['test']);\r\n }\r\n\r\n static dev() {\r\n GenesisConfig.init(GenesisConfig.CONFIGS['dev']);\r\n }\r\n\r\n /**\r\n * @param {{NETWORK_ID:number,NETWORK_NAME:string}} config\r\n */\r\n static init(config) {\r\n if (GenesisConfig._config) throw new Error('GenesisConfig already initialized');\r\n if (!config.NETWORK_ID) throw new Error('Config is missing network id');\r\n if (!config.NETWORK_NAME) throw new Error('Config is missing network name');\r\n\r\n GenesisConfig._config = config;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n static get NETWORK_ID() {\r\n if (!GenesisConfig._config) throw new Error('GenesisConfig not initialized');\r\n return GenesisConfig._config.NETWORK_ID;\r\n }\r\n\r\n /**\r\n * @type {string}\r\n */\r\n static get NETWORK_NAME() {\r\n if (!GenesisConfig._config) throw new Error('GenesisConfig not initialized');\r\n return GenesisConfig._config.NETWORK_NAME;\r\n }\r\n\r\n /**\r\n * @param {number} networkId\r\n * @return {string}\r\n */\r\n static networkIdToNetworkName(networkId) {\r\n for (const key of Object.keys(GenesisConfig.CONFIGS)) {\r\n const config = GenesisConfig.CONFIGS[key];\r\n if (networkId === config.NETWORK_ID) {\r\n return config.NETWORK_NAME;\r\n }\r\n }\r\n throw new Error(`Unable to find networkName for networkId ${networkId}`);\r\n }\r\n\r\n /**\r\n * @param {number|string} networkId\r\n * @return {number}\r\n */\r\n static networkIdFromAny(networkId) {\r\n if (typeof networkId === 'number') return networkId;\r\n if (GenesisConfig.CONFIGS[networkId]) {\r\n return GenesisConfig.CONFIGS[networkId].NETWORK_ID;\r\n }\r\n throw new Error(`Unable to find networkId for ${networkId}`);\r\n }\r\n}\r\nClass.register(GenesisConfig);\r\n\r\nGenesisConfig.CONFIGS = {\r\n 'main': {\r\n NETWORK_ID: 12,\r\n NETWORK_NAME: 'main'\r\n },\r\n\r\n 'test': {\r\n NETWORK_ID: 1,\r\n NETWORK_NAME: 'test'\r\n },\r\n\r\n 'dev': {\r\n NETWORK_ID: 2,\r\n NETWORK_NAME: 'dev'\r\n }\r\n};\r\n"," exports._loaded = true;\r\n if (typeof exports._onload === 'function') exports._onload();\r\n return exports;\r\n})(Krypton);\r\n"]}