{"version":3,"sources":["webpack:///./node_modules/elliptic/lib/elliptic/eddsa/key.js","webpack:///./node_modules/elliptic/lib/elliptic/eddsa/signature.js","webpack:///./node_modules/elliptic/lib/elliptic/eddsa/index.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/signature.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/index.js","webpack:///./node_modules/elliptic/lib/elliptic/ec/key.js"],"names":["utils","assert","parseBytes","cachedProperty","KeyPair","eddsa","params","this","_secret","secret","isPoint","pub","_pub","_pubBytes","fromPublic","fromSecret","prototype","encodePoint","decodePoint","g","mul","priv","hash","lastIx","encodingLength","a","slice","decodeInt","privBytes","update","digest","sign","message","verify","sig","getSecret","enc","encode","getPublic","pubBytes","module","exports","BN","Signature","Array","isArray","R","S","_R","_S","_Rencoded","Rencoded","_Sencoded","Sencoded","encodeInt","toBytes","concat","toHex","toUpperCase","curves","EDDSA","curve","precompute","n","bitLength","pointClass","point","constructor","Math","ceil","sha512","key","keyFromSecret","r","hashInt","messagePrefix","s_","add","umod","makeSignature","keyFromPublic","h","SG","eq","i","arguments","length","intFromLE","getY","toArray","getX","isOdd","bytes","normed","xIsOdd","y","pointFromY","num","val","options","_importDER","s","undefined","recoveryParam","Position","place","getLength","buf","p","initial","octetLen","off","rmPadding","len","constructLength","arr","push","octets","log","LN2","data","rlen","slen","toDER","backHalf","res","HmacDRBG","rand","EC","hasOwnProperty","PresetCurve","nh","ushrn","keyPair","keyFromPrivate","fromPrivate","genKeyPair","drbg","pers","persEnc","entropy","hmacStrength","entropyEnc","nonce","byteLength","ns2","sub","generate","cmp","iaddn","_truncateToN","msg","truncOnly","delta","bkey","getPrivate","ns1","iter","k","cmpn","kp","isInfinity","kpX","invm","iadd","canonical","signature","sinv","u1","u2","_maxwellTrick","jmulAdd","eqXToP","mulAdd","recoverPubKey","j","e","isYOdd","isSecondKey","Error","pointFromX","rInv","s1","s2","getKeyRecoveryParam","Q","Qprime","ec","_importPrivate","privEnc","_importPublic","pubEnc","validate","result","reason","compact","toString","x","type","derive","inspect"],"mappings":"8FAEA,IAAIA,EAAQ,EAAQ,QAChBC,EAASD,EAAMC,OACfC,EAAaF,EAAME,WACnBC,EAAiBH,EAAMG,eAW3B,SAASC,EAAQC,EAAOC,GACtBC,KAAKF,MAAQA,EACbE,KAAKC,QAAUN,EAAWI,EAAOG,QAC7BJ,EAAMK,QAAQJ,EAAOK,KACvBJ,KAAKK,KAAON,EAAOK,IAEnBJ,KAAKM,UAAYX,EAAWI,EAAOK,KAGvCP,EAAQU,WAAa,SAAoBT,EAAOM,GAC9C,OAAIA,aAAeP,EACVO,EACF,IAAIP,EAAQC,EAAO,CAAEM,IAAKA,KAGnCP,EAAQW,WAAa,SAAoBV,EAAOI,GAC9C,OAAIA,aAAkBL,EACbK,EACF,IAAIL,EAAQC,EAAO,CAAEI,OAAQA,KAGtCL,EAAQY,UAAUP,OAAS,WACzB,OAAOF,KAAKC,SAGdL,EAAeC,EAAS,YAAY,WAClC,OAAOG,KAAKF,MAAMY,YAAYV,KAAKI,UAGrCR,EAAeC,EAAS,OAAO,WAC7B,OAAIG,KAAKM,UACAN,KAAKF,MAAMa,YAAYX,KAAKM,WAC9BN,KAAKF,MAAMc,EAAEC,IAAIb,KAAKc,WAG/BlB,EAAeC,EAAS,aAAa,WACnC,IAAIC,EAAQE,KAAKF,MACbiB,EAAOf,KAAKe,OACZC,EAASlB,EAAMmB,eAAiB,EAEhCC,EAAIH,EAAKI,MAAM,EAAGrB,EAAMmB,gBAK5B,OAJAC,EAAE,IAAM,IACRA,EAAEF,IAAW,IACbE,EAAEF,IAAW,GAENE,KAGTtB,EAAeC,EAAS,QAAQ,WAC9B,OAAOG,KAAKF,MAAMsB,UAAUpB,KAAKqB,gBAGnCzB,EAAeC,EAAS,QAAQ,WAC9B,OAAOG,KAAKF,MAAMiB,OAAOO,OAAOtB,KAAKE,UAAUqB,YAGjD3B,EAAeC,EAAS,iBAAiB,WACvC,OAAOG,KAAKe,OAAOI,MAAMnB,KAAKF,MAAMmB,mBAGtCpB,EAAQY,UAAUe,KAAO,SAAcC,GAErC,OADA/B,EAAOM,KAAKC,QAAS,2BACdD,KAAKF,MAAM0B,KAAKC,EAASzB,OAGlCH,EAAQY,UAAUiB,OAAS,SAAgBD,EAASE,GAClD,OAAO3B,KAAKF,MAAM4B,OAAOD,EAASE,EAAK3B,OAGzCH,EAAQY,UAAUmB,UAAY,SAAmBC,GAE/C,OADAnC,EAAOM,KAAKC,QAAS,0BACdR,EAAMqC,OAAO9B,KAAKE,SAAU2B,IAGrChC,EAAQY,UAAUsB,UAAY,SAAmBF,GAC/C,OAAOpC,EAAMqC,OAAO9B,KAAKgC,WAAYH,IAGvCI,EAAOC,QAAUrC,G,kCC5FjB,IAAIsC,EAAK,EAAQ,QACb1C,EAAQ,EAAQ,QAChBC,EAASD,EAAMC,OACfE,EAAiBH,EAAMG,eACvBD,EAAaF,EAAME,WAUvB,SAASyC,EAAUtC,EAAO6B,GACxB3B,KAAKF,MAAQA,EAEM,iBAAR6B,IACTA,EAAMhC,EAAWgC,IAEfU,MAAMC,QAAQX,KAChBA,EAAM,CACJY,EAAGZ,EAAIR,MAAM,EAAGrB,EAAMmB,gBACtBuB,EAAGb,EAAIR,MAAMrB,EAAMmB,kBAIvBvB,EAAOiC,EAAIY,GAAKZ,EAAIa,EAAG,4BAEnB1C,EAAMK,QAAQwB,EAAIY,KACpBvC,KAAKyC,GAAKd,EAAIY,GACZZ,EAAIa,aAAaL,IACnBnC,KAAK0C,GAAKf,EAAIa,GAEhBxC,KAAK2C,UAAYN,MAAMC,QAAQX,EAAIY,GAAKZ,EAAIY,EAAIZ,EAAIiB,SACpD5C,KAAK6C,UAAYR,MAAMC,QAAQX,EAAIa,GAAKb,EAAIa,EAAIb,EAAImB,SAGtDlD,EAAewC,EAAW,KAAK,WAC7B,OAAOpC,KAAKF,MAAMsB,UAAUpB,KAAK8C,eAGnClD,EAAewC,EAAW,KAAK,WAC7B,OAAOpC,KAAKF,MAAMa,YAAYX,KAAK4C,eAGrChD,EAAewC,EAAW,YAAY,WACpC,OAAOpC,KAAKF,MAAMY,YAAYV,KAAKuC,QAGrC3C,EAAewC,EAAW,YAAY,WACpC,OAAOpC,KAAKF,MAAMiD,UAAU/C,KAAKwC,QAGnCJ,EAAU3B,UAAUuC,QAAU,WAC5B,OAAOhD,KAAK4C,WAAWK,OAAOjD,KAAK8C,aAGrCV,EAAU3B,UAAUyC,MAAQ,WAC1B,OAAOzD,EAAMqC,OAAO9B,KAAKgD,UAAW,OAAOG,eAG7ClB,EAAOC,QAAUE,G,kCC9DjB,IAAIrB,EAAO,EAAQ,QACfqC,EAAS,EAAQ,QACjB3D,EAAQ,EAAQ,QAChBC,EAASD,EAAMC,OACfC,EAAaF,EAAME,WACnBE,EAAU,EAAQ,QAClBuC,EAAY,EAAQ,QAExB,SAASiB,EAAMC,GAGb,GAFA5D,EAAiB,YAAV4D,EAAqB,qCAEtBtD,gBAAgBqD,GACpB,OAAO,IAAIA,EAAMC,GAEfA,EAAQF,EAAOE,GAAOA,MAC1BtD,KAAKsD,MAAQA,EACbtD,KAAKY,EAAI0C,EAAM1C,EACfZ,KAAKY,EAAE2C,WAAWD,EAAME,EAAEC,YAAc,GAExCzD,KAAK0D,WAAaJ,EAAMK,QAAQC,YAChC5D,KAAKiB,eAAiB4C,KAAKC,KAAKR,EAAME,EAAEC,YAAc,GACtDzD,KAAKe,KAAOA,EAAKgD,OAGnB9B,EAAOC,QAAUmB,EAOjBA,EAAM5C,UAAUe,KAAO,SAAcC,EAASvB,GAC5CuB,EAAU9B,EAAW8B,GACrB,IAAIuC,EAAMhE,KAAKiE,cAAc/D,GACzBgE,EAAIlE,KAAKmE,QAAQH,EAAII,gBAAiB3C,GACtCc,EAAIvC,KAAKY,EAAEC,IAAIqD,GACftB,EAAW5C,KAAKU,YAAY6B,GAC5B8B,EAAKrE,KAAKmE,QAAQvB,EAAUoB,EAAIhC,WAAYP,GAClCZ,IAAImD,EAAIlD,QAClB0B,EAAI0B,EAAEI,IAAID,GAAIE,KAAKvE,KAAKsD,MAAME,GAClC,OAAOxD,KAAKwE,cAAc,CAAEjC,EAAGA,EAAGC,EAAGA,EAAGI,SAAUA,KASpDS,EAAM5C,UAAUiB,OAAS,SAAgBD,EAASE,EAAKvB,GACrDqB,EAAU9B,EAAW8B,GACrBE,EAAM3B,KAAKwE,cAAc7C,GACzB,IAAIqC,EAAMhE,KAAKyE,cAAcrE,GACzBsE,EAAI1E,KAAKmE,QAAQxC,EAAIiB,WAAYoB,EAAIhC,WAAYP,GACjDkD,EAAK3E,KAAKY,EAAEC,IAAIc,EAAIa,KAExB,OADcb,EAAIY,IAAI+B,IAAIN,EAAI5D,MAAMS,IAAI6D,IACzBE,GAAGD,IAGpBtB,EAAM5C,UAAU0D,QAAU,WAExB,IADA,IAAIpD,EAAOf,KAAKe,OACP8D,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IACpC9D,EAAKO,OAAOwD,UAAUD,IACxB,OAAOpF,EAAMuF,UAAUjE,EAAKQ,UAAUgD,KAAKvE,KAAKsD,MAAME,IAGxDH,EAAM5C,UAAUgE,cAAgB,SAAuBrE,GACrD,OAAOP,EAAQU,WAAWP,KAAMI,IAGlCiD,EAAM5C,UAAUwD,cAAgB,SAAuB/D,GACrD,OAAOL,EAAQW,WAAWR,KAAME,IAGlCmD,EAAM5C,UAAU+D,cAAgB,SAAuB7C,GACrD,OAAIA,aAAeS,EACVT,EACF,IAAIS,EAAUpC,KAAM2B,IAW7B0B,EAAM5C,UAAUC,YAAc,SAAqBiD,GACjD,IAAI9B,EAAM8B,EAAMsB,OAAOC,QAAQ,KAAMlF,KAAKiB,gBAE1C,OADAY,EAAI7B,KAAKiB,eAAiB,IAAM0C,EAAMwB,OAAOC,QAAU,IAAO,EACvDvD,GAGTwB,EAAM5C,UAAUE,YAAc,SAAqB0E,GAGjD,IAAIrE,GAFJqE,EAAQ5F,EAAME,WAAW0F,IAENN,OAAS,EACxBO,EAASD,EAAMlE,MAAM,EAAGH,GAAQiC,QAAuB,IAAhBoC,EAAMrE,IAC7CuE,EAAoC,IAAV,IAAhBF,EAAMrE,IAEhBwE,EAAI/F,EAAMuF,UAAUM,GACxB,OAAOtF,KAAKsD,MAAMmC,WAAWD,EAAGD,IAGlClC,EAAM5C,UAAUsC,UAAY,SAAmB2C,GAC7C,OAAOA,EAAIR,QAAQ,KAAMlF,KAAKiB,iBAGhCoC,EAAM5C,UAAUW,UAAY,SAAmBiE,GAC7C,OAAO5F,EAAMuF,UAAUK,IAGzBhC,EAAM5C,UAAUN,QAAU,SAAiBwF,GACzC,OAAOA,aAAe3F,KAAK0D,a,oCClH7B,IAAIvB,EAAK,EAAQ,QAEb1C,EAAQ,EAAQ,QAChBC,EAASD,EAAMC,OAEnB,SAAS0C,EAAUwD,EAAS/D,GAC1B,GAAI+D,aAAmBxD,EACrB,OAAOwD,EAEL5F,KAAK6F,WAAWD,EAAS/D,KAG7BnC,EAAOkG,EAAQ1B,GAAK0B,EAAQE,EAAG,4BAC/B9F,KAAKkE,EAAI,IAAI/B,EAAGyD,EAAQ1B,EAAG,IAC3BlE,KAAK8F,EAAI,IAAI3D,EAAGyD,EAAQE,EAAG,SACGC,IAA1BH,EAAQI,cACVhG,KAAKgG,cAAgB,KAErBhG,KAAKgG,cAAgBJ,EAAQI,eAIjC,SAASC,IACPjG,KAAKkG,MAAQ,EAGf,SAASC,EAAUC,EAAKC,GACtB,IAAIC,EAAUF,EAAIC,EAAEH,SACpB,KAAgB,IAAVI,GACJ,OAAOA,EAIT,IAFA,IAAIC,EAAqB,GAAVD,EACXX,EAAM,EACDd,EAAI,EAAG2B,EAAMH,EAAEH,MAAOrB,EAAI0B,EAAU1B,IAAK2B,IAChDb,IAAQ,EACRA,GAAOS,EAAII,GAGb,OADAH,EAAEH,MAAQM,EACHb,EAGT,SAASc,EAAUL,GAGjB,IAFA,IAAIvB,EAAI,EACJ6B,EAAMN,EAAIrB,OAAS,GACfqB,EAAIvB,MAAqB,IAAbuB,EAAIvB,EAAI,KAAcA,EAAI6B,GAC5C7B,IAEF,OAAU,IAANA,EACKuB,EAEFA,EAAIjF,MAAM0D,GAyCnB,SAAS8B,EAAgBC,EAAKF,GAC5B,GAAIA,EAAM,IACRE,EAAIC,KAAKH,OADX,CAIA,IAAII,EAAS,GAAKjD,KAAKkD,IAAIL,GAAO7C,KAAKmD,MAAQ,GAE/C,IADAJ,EAAIC,KAAc,IAATC,KACAA,GACPF,EAAIC,KAAMH,KAASI,GAAU,GAAM,KAErCF,EAAIC,KAAKH,IAjFXzE,EAAOC,QAAUE,EAiCjBA,EAAU3B,UAAUoF,WAAa,SAAoBoB,EAAMpF,GACzDoF,EAAOxH,EAAMyF,QAAQ+B,EAAMpF,GAC3B,IAAIwE,EAAI,IAAIJ,EACZ,GAAwB,KAApBgB,EAAKZ,EAAEH,SACT,OAAO,EAGT,GADUC,EAAUc,EAAMZ,GACfA,EAAEH,QAAWe,EAAKlC,OAC3B,OAAO,EAET,GAAwB,IAApBkC,EAAKZ,EAAEH,SACT,OAAO,EAET,IAAIgB,EAAOf,EAAUc,EAAMZ,GACvBnC,EAAI+C,EAAK9F,MAAMkF,EAAEH,MAAOgB,EAAOb,EAAEH,OAErC,GADAG,EAAEH,OAASgB,EACa,IAApBD,EAAKZ,EAAEH,SACT,OAAO,EAET,IAAIiB,EAAOhB,EAAUc,EAAMZ,GAC3B,GAAIY,EAAKlC,SAAWoC,EAAOd,EAAEH,MAC3B,OAAO,EAET,IAAIJ,EAAImB,EAAK9F,MAAMkF,EAAEH,MAAOiB,EAAOd,EAAEH,OAYrC,OAXa,IAAThC,EAAE,IAAoB,IAAPA,EAAE,KACnBA,EAAIA,EAAE/C,MAAM,IAED,IAAT2E,EAAE,IAAoB,IAAPA,EAAE,KACnBA,EAAIA,EAAE3E,MAAM,IAGdnB,KAAKkE,EAAI,IAAI/B,EAAG+B,GAChBlE,KAAK8F,EAAI,IAAI3D,EAAG2D,GAChB9F,KAAKgG,cAAgB,MAEd,GAgBT5D,EAAU3B,UAAU2G,MAAQ,SAAevF,GACzC,IAAIqC,EAAIlE,KAAKkE,EAAEgB,UACXY,EAAI9F,KAAK8F,EAAEZ,UAYf,IATW,IAAPhB,EAAE,KACJA,EAAI,CAAE,GAAIjB,OAAOiB,IAER,IAAP4B,EAAE,KACJA,EAAI,CAAE,GAAI7C,OAAO6C,IAEnB5B,EAAIuC,EAAUvC,GACd4B,EAAIW,EAAUX,KAENA,EAAE,IAAe,IAAPA,EAAE,KAClBA,EAAIA,EAAE3E,MAAM,GAEd,IAAIyF,EAAM,CAAE,GACZD,EAAgBC,EAAK1C,EAAEa,SACvB6B,EAAMA,EAAI3D,OAAOiB,IACb2C,KAAK,GACTF,EAAgBC,EAAKd,EAAEf,QACvB,IAAIsC,EAAWT,EAAI3D,OAAO6C,GACtBwB,EAAM,CAAE,IAGZ,OAFAX,EAAgBW,EAAKD,EAAStC,QAC9BuC,EAAMA,EAAIrE,OAAOoE,GACV5H,EAAMqC,OAAOwF,EAAKzF,K,kCClI3B,IAAIM,EAAK,EAAQ,QACboF,EAAW,EAAQ,QACnB9H,EAAQ,EAAQ,QAChB2D,EAAS,EAAQ,QACjBoE,EAAO,EAAQ,QACf9H,EAASD,EAAMC,OAEfG,EAAU,EAAQ,QAClBuC,EAAY,EAAQ,QAExB,SAASqF,EAAG7B,GACV,KAAM5F,gBAAgByH,GACpB,OAAO,IAAIA,EAAG7B,GAGO,iBAAZA,IACTlG,EAAO0D,EAAOsE,eAAe9B,GAAU,iBAAmBA,GAE1DA,EAAUxC,EAAOwC,IAIfA,aAAmBxC,EAAOuE,cAC5B/B,EAAU,CAAEtC,MAAOsC,IAErB5F,KAAKsD,MAAQsC,EAAQtC,MAAMA,MAC3BtD,KAAKwD,EAAIxD,KAAKsD,MAAME,EACpBxD,KAAK4H,GAAK5H,KAAKwD,EAAEqE,MAAM,GACvB7H,KAAKY,EAAIZ,KAAKsD,MAAM1C,EAGpBZ,KAAKY,EAAIgF,EAAQtC,MAAM1C,EACvBZ,KAAKY,EAAE2C,WAAWqC,EAAQtC,MAAME,EAAEC,YAAc,GAGhDzD,KAAKe,KAAO6E,EAAQ7E,MAAQ6E,EAAQtC,MAAMvC,KAE5CkB,EAAOC,QAAUuF,EAEjBA,EAAGhH,UAAUqH,QAAU,SAAiBlC,GACtC,OAAO,IAAI/F,EAAQG,KAAM4F,IAG3B6B,EAAGhH,UAAUsH,eAAiB,SAAwBjH,EAAMe,GAC1D,OAAOhC,EAAQmI,YAAYhI,KAAMc,EAAMe,IAGzC4F,EAAGhH,UAAUgE,cAAgB,SAAuBrE,EAAKyB,GACvD,OAAOhC,EAAQU,WAAWP,KAAMI,EAAKyB,IAGvC4F,EAAGhH,UAAUwH,WAAa,SAAoBrC,GACvCA,IACHA,EAAU,IAcZ,IAXA,IAAIsC,EAAO,IAAIX,EAAS,CACtBxG,KAAMf,KAAKe,KACXoH,KAAMvC,EAAQuC,KACdC,QAASxC,EAAQwC,SAAW,OAC5BC,QAASzC,EAAQyC,SAAWb,EAAKxH,KAAKe,KAAKuH,cAC3CC,WAAY3C,EAAQyC,SAAWzC,EAAQ2C,YAAc,OACrDC,MAAOxI,KAAKwD,EAAE0B,YAGZG,EAAQrF,KAAKwD,EAAEiF,aACfC,EAAM1I,KAAKwD,EAAEmF,IAAI,IAAIxG,EAAG,MACzB,CACD,IAAIrB,EAAO,IAAIqB,EAAG+F,EAAKU,SAASvD,IAChC,KAAIvE,EAAK+H,IAAIH,GAAO,GAIpB,OADA5H,EAAKgI,MAAM,GACJ9I,KAAK+H,eAAejH,KAI/B2G,EAAGhH,UAAUsI,aAAe,SAAqBC,EAAKC,GACpD,IAAIC,EAA2B,EAAnBF,EAAIP,aAAmBzI,KAAKwD,EAAEC,YAG1C,OAFIyF,EAAQ,IACVF,EAAMA,EAAInB,MAAMqB,KACbD,GAAaD,EAAIH,IAAI7I,KAAKwD,IAAM,EAC5BwF,EAAIL,IAAI3I,KAAKwD,GAEbwF,GAGXvB,EAAGhH,UAAUe,KAAO,SAAcwH,EAAKhF,EAAKnC,EAAK+D,GAC5B,iBAAR/D,IACT+D,EAAU/D,EACVA,EAAM,MAEH+D,IACHA,EAAU,IAEZ5B,EAAMhE,KAAK+H,eAAe/D,EAAKnC,GAC/BmH,EAAMhJ,KAAK+I,aAAa,IAAI5G,EAAG6G,EAAK,KAqBpC,IAlBA,IAAI3D,EAAQrF,KAAKwD,EAAEiF,aACfU,EAAOnF,EAAIoF,aAAalE,QAAQ,KAAMG,GAGtCmD,EAAQQ,EAAI9D,QAAQ,KAAMG,GAG1B6C,EAAO,IAAIX,EAAS,CACtBxG,KAAMf,KAAKe,KACXsH,QAASc,EACTX,MAAOA,EACPL,KAAMvC,EAAQuC,KACdC,QAASxC,EAAQwC,SAAW,SAI1BiB,EAAMrJ,KAAKwD,EAAEmF,IAAI,IAAIxG,EAAG,IAEnBmH,EAAO,GAASA,IAAQ,CAC/B,IAAIC,EAAI3D,EAAQ2D,EACZ3D,EAAQ2D,EAAED,GACV,IAAInH,EAAG+F,EAAKU,SAAS5I,KAAKwD,EAAEiF,eAEhC,MADAc,EAAIvJ,KAAK+I,aAAaQ,GAAG,IACnBC,KAAK,IAAM,GAAKD,EAAEV,IAAIQ,IAAQ,GAApC,CAGA,IAAII,EAAKzJ,KAAKY,EAAEC,IAAI0I,GACpB,IAAIE,EAAGC,aAAP,CAGA,IAAIC,EAAMF,EAAGtE,OACTjB,EAAIyF,EAAIpF,KAAKvE,KAAKwD,GACtB,GAAkB,IAAdU,EAAEsF,KAAK,GAAX,CAGA,IAAI1D,EAAIyD,EAAEK,KAAK5J,KAAKwD,GAAG3C,IAAIqD,EAAErD,IAAImD,EAAIoF,cAAcS,KAAKb,IAExD,GAAkB,KADlBlD,EAAIA,EAAEvB,KAAKvE,KAAKwD,IACVgG,KAAK,GAAX,CAGA,IAAIxD,GAAiByD,EAAGxE,OAAOG,QAAU,EAAI,IACT,IAAfuE,EAAId,IAAI3E,GAAW,EAAI,GAQ5C,OALI0B,EAAQkE,WAAahE,EAAE+C,IAAI7I,KAAK4H,IAAM,IACxC9B,EAAI9F,KAAKwD,EAAEmF,IAAI7C,GACfE,GAAiB,GAGZ,IAAI5D,EAAU,CAAE8B,EAAGA,EAAG4B,EAAGA,EAAGE,cAAeA,UAItDyB,EAAGhH,UAAUiB,OAAS,SAAgBsH,EAAKe,EAAW/F,EAAKnC,GACzDmH,EAAMhJ,KAAK+I,aAAa,IAAI5G,EAAG6G,EAAK,KACpChF,EAAMhE,KAAKyE,cAAcT,EAAKnC,GAI9B,IAAIqC,GAHJ6F,EAAY,IAAI3H,EAAU2H,EAAW,QAGnB7F,EACd4B,EAAIiE,EAAUjE,EAClB,GAAI5B,EAAEsF,KAAK,GAAK,GAAKtF,EAAE2E,IAAI7I,KAAKwD,IAAM,EACpC,OAAO,EACT,GAAIsC,EAAE0D,KAAK,GAAK,GAAK1D,EAAE+C,IAAI7I,KAAKwD,IAAM,EACpC,OAAO,EAGT,IAeI6C,EAfA2D,EAAOlE,EAAE8D,KAAK5J,KAAKwD,GACnByG,EAAKD,EAAKnJ,IAAImI,GAAKzE,KAAKvE,KAAKwD,GAC7B0G,EAAKF,EAAKnJ,IAAIqD,GAAGK,KAAKvE,KAAKwD,GAE/B,OAAKxD,KAAKsD,MAAM6G,gBAWZ9D,EAAIrG,KAAKY,EAAEwJ,QAAQH,EAAIjG,EAAIjC,YAAamI,IACtCR,cAMCrD,EAAEgE,OAAOnG,KAjBVmC,EAAIrG,KAAKY,EAAE0J,OAAOL,EAAIjG,EAAIjC,YAAamI,IACrCR,cAGkC,IAAjCrD,EAAElB,OAAOZ,KAAKvE,KAAKwD,GAAGqF,IAAI3E,IAgBrCuD,EAAGhH,UAAU8J,cAAgB,SAASvB,EAAKe,EAAWS,EAAG3I,GACvDnC,GAAQ,EAAI8K,KAAOA,EAAG,4CACtBT,EAAY,IAAI3H,EAAU2H,EAAWlI,GAErC,IAAI2B,EAAIxD,KAAKwD,EACTiH,EAAI,IAAItI,EAAG6G,GACX9E,EAAI6F,EAAU7F,EACd4B,EAAIiE,EAAUjE,EAGd4E,EAAa,EAAJF,EACTG,EAAcH,GAAK,EACvB,GAAItG,EAAE2E,IAAI7I,KAAKsD,MAAM+C,EAAE9B,KAAKvE,KAAKsD,MAAME,KAAO,GAAKmH,EACjD,MAAM,IAAIC,MAAM,wCAIhB1G,EADEyG,EACE3K,KAAKsD,MAAMuH,WAAW3G,EAAEI,IAAItE,KAAKsD,MAAME,GAAIkH,GAE3C1K,KAAKsD,MAAMuH,WAAW3G,EAAGwG,GAE/B,IAAII,EAAOf,EAAU7F,EAAE0F,KAAKpG,GACxBuH,EAAKvH,EAAEmF,IAAI8B,GAAG5J,IAAIiK,GAAMvG,KAAKf,GAC7BwH,EAAKlF,EAAEjF,IAAIiK,GAAMvG,KAAKf,GAI1B,OAAOxD,KAAKY,EAAE0J,OAAOS,EAAI7G,EAAG8G,IAG9BvD,EAAGhH,UAAUwK,oBAAsB,SAASR,EAAGV,EAAWmB,EAAGrJ,GAE3D,GAAgC,QADhCkI,EAAY,IAAI3H,EAAU2H,EAAWlI,IACvBmE,cACZ,OAAO+D,EAAU/D,cAEnB,IAAK,IAAInB,EAAI,EAAGA,EAAI,EAAGA,IAAK,CAC1B,IAAIsG,EACJ,IACEA,EAASnL,KAAKuK,cAAcE,EAAGV,EAAWlF,GAC1C,MAAO4F,GACP,SAGF,GAAIU,EAAOvG,GAAGsG,GACZ,OAAOrG,EAEX,MAAM,IAAI+F,MAAM,0C,kCC7OlB,IAAIzI,EAAK,EAAQ,QAEbzC,EADQ,EAAQ,QACDA,OAEnB,SAASG,EAAQuL,EAAIxF,GACnB5F,KAAKoL,GAAKA,EACVpL,KAAKc,KAAO,KACZd,KAAKI,IAAM,KAGPwF,EAAQ9E,MACVd,KAAKqL,eAAezF,EAAQ9E,KAAM8E,EAAQ0F,SACxC1F,EAAQxF,KACVJ,KAAKuL,cAAc3F,EAAQxF,IAAKwF,EAAQ4F,QAE5CvJ,EAAOC,QAAUrC,EAEjBA,EAAQU,WAAa,SAAoB6K,EAAIhL,EAAKyB,GAChD,OAAIzB,aAAeP,EACVO,EAEF,IAAIP,EAAQuL,EAAI,CACrBhL,IAAKA,EACLoL,OAAQ3J,KAIZhC,EAAQmI,YAAc,SAAqBoD,EAAItK,EAAMe,GACnD,OAAIf,aAAgBjB,EACXiB,EAEF,IAAIjB,EAAQuL,EAAI,CACrBtK,KAAMA,EACNwK,QAASzJ,KAIbhC,EAAQY,UAAUgL,SAAW,WAC3B,IAAIrL,EAAMJ,KAAK+B,YAEf,OAAI3B,EAAIsJ,aACC,CAAEgC,QAAQ,EAAOC,OAAQ,sBAC7BvL,EAAIqL,WAEJrL,EAAIS,IAAIb,KAAKoL,GAAG9H,MAAME,GAAGkG,aAGvB,CAAEgC,QAAQ,EAAMC,OAAQ,MAFtB,CAAED,QAAQ,EAAOC,OAAQ,uBAFzB,CAAED,QAAQ,EAAOC,OAAQ,8BAOpC9L,EAAQY,UAAUsB,UAAY,SAAmB6J,EAAS/J,GAUxD,MARuB,iBAAZ+J,IACT/J,EAAM+J,EACNA,EAAU,MAGP5L,KAAKI,MACRJ,KAAKI,IAAMJ,KAAKoL,GAAGxK,EAAEC,IAAIb,KAAKc,OAE3Be,EAGE7B,KAAKI,IAAI0B,OAAOD,EAAK+J,GAFnB5L,KAAKI,KAKhBP,EAAQY,UAAU2I,WAAa,SAAoBvH,GACjD,MAAY,QAARA,EACK7B,KAAKc,KAAK+K,SAAS,GAAI,GAEvB7L,KAAKc,MAGhBjB,EAAQY,UAAU4K,eAAiB,SAAwBrH,EAAKnC,GAC9D7B,KAAKc,KAAO,IAAIqB,EAAG6B,EAAKnC,GAAO,IAI/B7B,KAAKc,KAAOd,KAAKc,KAAKyD,KAAKvE,KAAKoL,GAAG9H,MAAME,IAG3C3D,EAAQY,UAAU8K,cAAgB,SAAuBvH,EAAKnC,GAC5D,GAAImC,EAAI8H,GAAK9H,EAAIwB,EAWf,MAP2B,SAAvBxF,KAAKoL,GAAG9H,MAAMyI,KAChBrM,EAAOsE,EAAI8H,EAAG,qBACkB,UAAvB9L,KAAKoL,GAAG9H,MAAMyI,MACS,YAAvB/L,KAAKoL,GAAG9H,MAAMyI,MACvBrM,EAAOsE,EAAI8H,GAAK9H,EAAIwB,EAAG,qCAEzBxF,KAAKI,IAAMJ,KAAKoL,GAAG9H,MAAMK,MAAMK,EAAI8H,EAAG9H,EAAIwB,IAG5CxF,KAAKI,IAAMJ,KAAKoL,GAAG9H,MAAM3C,YAAYqD,EAAKnC,IAI5ChC,EAAQY,UAAUuL,OAAS,SAAgB5L,GACzC,OAAOA,EAAIS,IAAIb,KAAKc,MAAMqE,QAI5BtF,EAAQY,UAAUe,KAAO,SAAcwH,EAAKnH,EAAK+D,GAC/C,OAAO5F,KAAKoL,GAAG5J,KAAKwH,EAAKhJ,KAAM6B,EAAK+D,IAGtC/F,EAAQY,UAAUiB,OAAS,SAAgBsH,EAAKe,GAC9C,OAAO/J,KAAKoL,GAAG1J,OAAOsH,EAAKe,EAAW/J,OAGxCH,EAAQY,UAAUwL,QAAU,WAC1B,MAAO,eAAiBjM,KAAKc,MAAQd,KAAKc,KAAK+K,SAAS,GAAI,IACrD,UAAY7L,KAAKI,KAAOJ,KAAKI,IAAI6L,WAAa","file":"vendor.elliptic~fc917e3c.17a42c1924660d8c31df.chunk.js","sourcesContent":["'use strict';\n\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar cachedProperty = utils.cachedProperty;\n\n/**\n* @param {EDDSA} eddsa - instance\n* @param {Object} params - public/private key parameters\n*\n* @param {Array<Byte>} [params.secret] - secret seed bytes\n* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)\n* @param {Array<Byte>} [params.pub] - public key point encoded as bytes\n*\n*/\nfunction KeyPair(eddsa, params) {\n  this.eddsa = eddsa;\n  this._secret = parseBytes(params.secret);\n  if (eddsa.isPoint(params.pub))\n    this._pub = params.pub;\n  else\n    this._pubBytes = parseBytes(params.pub);\n}\n\nKeyPair.fromPublic = function fromPublic(eddsa, pub) {\n  if (pub instanceof KeyPair)\n    return pub;\n  return new KeyPair(eddsa, { pub: pub });\n};\n\nKeyPair.fromSecret = function fromSecret(eddsa, secret) {\n  if (secret instanceof KeyPair)\n    return secret;\n  return new KeyPair(eddsa, { secret: secret });\n};\n\nKeyPair.prototype.secret = function secret() {\n  return this._secret;\n};\n\ncachedProperty(KeyPair, 'pubBytes', function pubBytes() {\n  return this.eddsa.encodePoint(this.pub());\n});\n\ncachedProperty(KeyPair, 'pub', function pub() {\n  if (this._pubBytes)\n    return this.eddsa.decodePoint(this._pubBytes);\n  return this.eddsa.g.mul(this.priv());\n});\n\ncachedProperty(KeyPair, 'privBytes', function privBytes() {\n  var eddsa = this.eddsa;\n  var hash = this.hash();\n  var lastIx = eddsa.encodingLength - 1;\n\n  var a = hash.slice(0, eddsa.encodingLength);\n  a[0] &= 248;\n  a[lastIx] &= 127;\n  a[lastIx] |= 64;\n\n  return a;\n});\n\ncachedProperty(KeyPair, 'priv', function priv() {\n  return this.eddsa.decodeInt(this.privBytes());\n});\n\ncachedProperty(KeyPair, 'hash', function hash() {\n  return this.eddsa.hash().update(this.secret()).digest();\n});\n\ncachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {\n  return this.hash().slice(this.eddsa.encodingLength);\n});\n\nKeyPair.prototype.sign = function sign(message) {\n  assert(this._secret, 'KeyPair can only verify');\n  return this.eddsa.sign(message, this);\n};\n\nKeyPair.prototype.verify = function verify(message, sig) {\n  return this.eddsa.verify(message, sig, this);\n};\n\nKeyPair.prototype.getSecret = function getSecret(enc) {\n  assert(this._secret, 'KeyPair is public only');\n  return utils.encode(this.secret(), enc);\n};\n\nKeyPair.prototype.getPublic = function getPublic(enc) {\n  return utils.encode(this.pubBytes(), enc);\n};\n\nmodule.exports = KeyPair;\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar cachedProperty = utils.cachedProperty;\nvar parseBytes = utils.parseBytes;\n\n/**\n* @param {EDDSA} eddsa - eddsa instance\n* @param {Array<Bytes>|Object} sig -\n* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes\n* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes\n* @param {Array<Bytes>} [sig.Rencoded] - R point encoded\n* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded\n*/\nfunction Signature(eddsa, sig) {\n  this.eddsa = eddsa;\n\n  if (typeof sig !== 'object')\n    sig = parseBytes(sig);\n\n  if (Array.isArray(sig)) {\n    sig = {\n      R: sig.slice(0, eddsa.encodingLength),\n      S: sig.slice(eddsa.encodingLength)\n    };\n  }\n\n  assert(sig.R && sig.S, 'Signature without R or S');\n\n  if (eddsa.isPoint(sig.R))\n    this._R = sig.R;\n  if (sig.S instanceof BN)\n    this._S = sig.S;\n\n  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;\n  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;\n}\n\ncachedProperty(Signature, 'S', function S() {\n  return this.eddsa.decodeInt(this.Sencoded());\n});\n\ncachedProperty(Signature, 'R', function R() {\n  return this.eddsa.decodePoint(this.Rencoded());\n});\n\ncachedProperty(Signature, 'Rencoded', function Rencoded() {\n  return this.eddsa.encodePoint(this.R());\n});\n\ncachedProperty(Signature, 'Sencoded', function Sencoded() {\n  return this.eddsa.encodeInt(this.S());\n});\n\nSignature.prototype.toBytes = function toBytes() {\n  return this.Rencoded().concat(this.Sencoded());\n};\n\nSignature.prototype.toHex = function toHex() {\n  return utils.encode(this.toBytes(), 'hex').toUpperCase();\n};\n\nmodule.exports = Signature;\n","'use strict';\n\nvar hash = require('hash.js');\nvar curves = require('../curves');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EDDSA(curve) {\n  assert(curve === 'ed25519', 'only tested with ed25519 so far');\n\n  if (!(this instanceof EDDSA))\n    return new EDDSA(curve);\n\n  var curve = curves[curve].curve;\n  this.curve = curve;\n  this.g = curve.g;\n  this.g.precompute(curve.n.bitLength() + 1);\n\n  this.pointClass = curve.point().constructor;\n  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);\n  this.hash = hash.sha512;\n}\n\nmodule.exports = EDDSA;\n\n/**\n* @param {Array|String} message - message bytes\n* @param {Array|String|KeyPair} secret - secret bytes or a keypair\n* @returns {Signature} - signature\n*/\nEDDSA.prototype.sign = function sign(message, secret) {\n  message = parseBytes(message);\n  var key = this.keyFromSecret(secret);\n  var r = this.hashInt(key.messagePrefix(), message);\n  var R = this.g.mul(r);\n  var Rencoded = this.encodePoint(R);\n  var s_ = this.hashInt(Rencoded, key.pubBytes(), message)\n               .mul(key.priv());\n  var S = r.add(s_).umod(this.curve.n);\n  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });\n};\n\n/**\n* @param {Array} message - message bytes\n* @param {Array|String|Signature} sig - sig bytes\n* @param {Array|String|Point|KeyPair} pub - public key\n* @returns {Boolean} - true if public key matches sig of message\n*/\nEDDSA.prototype.verify = function verify(message, sig, pub) {\n  message = parseBytes(message);\n  sig = this.makeSignature(sig);\n  var key = this.keyFromPublic(pub);\n  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);\n  var SG = this.g.mul(sig.S());\n  var RplusAh = sig.R().add(key.pub().mul(h));\n  return RplusAh.eq(SG);\n};\n\nEDDSA.prototype.hashInt = function hashInt() {\n  var hash = this.hash();\n  for (var i = 0; i < arguments.length; i++)\n    hash.update(arguments[i]);\n  return utils.intFromLE(hash.digest()).umod(this.curve.n);\n};\n\nEDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {\n  return KeyPair.fromPublic(this, pub);\n};\n\nEDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {\n  return KeyPair.fromSecret(this, secret);\n};\n\nEDDSA.prototype.makeSignature = function makeSignature(sig) {\n  if (sig instanceof Signature)\n    return sig;\n  return new Signature(this, sig);\n};\n\n/**\n* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2\n*\n* EDDSA defines methods for encoding and decoding points and integers. These are\n* helper convenience methods, that pass along to utility functions implied\n* parameters.\n*\n*/\nEDDSA.prototype.encodePoint = function encodePoint(point) {\n  var enc = point.getY().toArray('le', this.encodingLength);\n  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;\n  return enc;\n};\n\nEDDSA.prototype.decodePoint = function decodePoint(bytes) {\n  bytes = utils.parseBytes(bytes);\n\n  var lastIx = bytes.length - 1;\n  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);\n  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;\n\n  var y = utils.intFromLE(normed);\n  return this.curve.pointFromY(y, xIsOdd);\n};\n\nEDDSA.prototype.encodeInt = function encodeInt(num) {\n  return num.toArray('le', this.encodingLength);\n};\n\nEDDSA.prototype.decodeInt = function decodeInt(bytes) {\n  return utils.intFromLE(bytes);\n};\n\nEDDSA.prototype.isPoint = function isPoint(val) {\n  return val instanceof this.pointClass;\n};\n","'use strict';\n\nvar BN = require('bn.js');\n\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction Signature(options, enc) {\n  if (options instanceof Signature)\n    return options;\n\n  if (this._importDER(options, enc))\n    return;\n\n  assert(options.r && options.s, 'Signature without r or s');\n  this.r = new BN(options.r, 16);\n  this.s = new BN(options.s, 16);\n  if (options.recoveryParam === undefined)\n    this.recoveryParam = null;\n  else\n    this.recoveryParam = options.recoveryParam;\n}\nmodule.exports = Signature;\n\nfunction Position() {\n  this.place = 0;\n}\n\nfunction getLength(buf, p) {\n  var initial = buf[p.place++];\n  if (!(initial & 0x80)) {\n    return initial;\n  }\n  var octetLen = initial & 0xf;\n  var val = 0;\n  for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n    val <<= 8;\n    val |= buf[off];\n  }\n  p.place = off;\n  return val;\n}\n\nfunction rmPadding(buf) {\n  var i = 0;\n  var len = buf.length - 1;\n  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n    i++;\n  }\n  if (i === 0) {\n    return buf;\n  }\n  return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n  data = utils.toArray(data, enc);\n  var p = new Position();\n  if (data[p.place++] !== 0x30) {\n    return false;\n  }\n  var len = getLength(data, p);\n  if ((len + p.place) !== data.length) {\n    return false;\n  }\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var rlen = getLength(data, p);\n  var r = data.slice(p.place, rlen + p.place);\n  p.place += rlen;\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var slen = getLength(data, p);\n  if (data.length !== slen + p.place) {\n    return false;\n  }\n  var s = data.slice(p.place, slen + p.place);\n  if (r[0] === 0 && (r[1] & 0x80)) {\n    r = r.slice(1);\n  }\n  if (s[0] === 0 && (s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n\n  this.r = new BN(r);\n  this.s = new BN(s);\n  this.recoveryParam = null;\n\n  return true;\n};\n\nfunction constructLength(arr, len) {\n  if (len < 0x80) {\n    arr.push(len);\n    return;\n  }\n  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n  arr.push(octets | 0x80);\n  while (--octets) {\n    arr.push((len >>> (octets << 3)) & 0xff);\n  }\n  arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n  var r = this.r.toArray();\n  var s = this.s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80)\n    r = [ 0 ].concat(r);\n  // Pad values\n  if (s[0] & 0x80)\n    s = [ 0 ].concat(s);\n\n  r = rmPadding(r);\n  s = rmPadding(s);\n\n  while (!s[0] && !(s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n  var arr = [ 0x02 ];\n  constructLength(arr, r.length);\n  arr = arr.concat(r);\n  arr.push(0x02);\n  constructLength(arr, s.length);\n  var backHalf = arr.concat(s);\n  var res = [ 0x30 ];\n  constructLength(res, backHalf.length);\n  res = res.concat(backHalf);\n  return utils.encode(res, enc);\n};\n","'use strict';\n\nvar BN = require('bn.js');\nvar HmacDRBG = require('hmac-drbg');\nvar utils = require('../utils');\nvar curves = require('../curves');\nvar rand = require('brorand');\nvar assert = utils.assert;\n\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EC(options) {\n  if (!(this instanceof EC))\n    return new EC(options);\n\n  // Shortcut `elliptic.ec(curve-name)`\n  if (typeof options === 'string') {\n    assert(curves.hasOwnProperty(options), 'Unknown curve ' + options);\n\n    options = curves[options];\n  }\n\n  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n  if (options instanceof curves.PresetCurve)\n    options = { curve: options };\n\n  this.curve = options.curve.curve;\n  this.n = this.curve.n;\n  this.nh = this.n.ushrn(1);\n  this.g = this.curve.g;\n\n  // Point on curve\n  this.g = options.curve.g;\n  this.g.precompute(options.curve.n.bitLength() + 1);\n\n  // Hash for function for DRBG\n  this.hash = options.hash || options.curve.hash;\n}\nmodule.exports = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n  return new KeyPair(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n  return KeyPair.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n  return KeyPair.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n  if (!options)\n    options = {};\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n    entropy: options.entropy || rand(this.hash.hmacStrength),\n    entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n    nonce: this.n.toArray()\n  });\n\n  var bytes = this.n.byteLength();\n  var ns2 = this.n.sub(new BN(2));\n  do {\n    var priv = new BN(drbg.generate(bytes));\n    if (priv.cmp(ns2) > 0)\n      continue;\n\n    priv.iaddn(1);\n    return this.keyFromPrivate(priv);\n  } while (true);\n};\n\nEC.prototype._truncateToN = function truncateToN(msg, truncOnly) {\n  var delta = msg.byteLength() * 8 - this.n.bitLength();\n  if (delta > 0)\n    msg = msg.ushrn(delta);\n  if (!truncOnly && msg.cmp(this.n) >= 0)\n    return msg.sub(this.n);\n  else\n    return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n  if (typeof enc === 'object') {\n    options = enc;\n    enc = null;\n  }\n  if (!options)\n    options = {};\n\n  key = this.keyFromPrivate(key, enc);\n  msg = this._truncateToN(new BN(msg, 16));\n\n  // Zero-extend key to provide enough entropy\n  var bytes = this.n.byteLength();\n  var bkey = key.getPrivate().toArray('be', bytes);\n\n  // Zero-extend nonce to have the same byte size as N\n  var nonce = msg.toArray('be', bytes);\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    entropy: bkey,\n    nonce: nonce,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8'\n  });\n\n  // Number of bytes to generate\n  var ns1 = this.n.sub(new BN(1));\n\n  for (var iter = 0; true; iter++) {\n    var k = options.k ?\n        options.k(iter) :\n        new BN(drbg.generate(this.n.byteLength()));\n    k = this._truncateToN(k, true);\n    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)\n      continue;\n\n    var kp = this.g.mul(k);\n    if (kp.isInfinity())\n      continue;\n\n    var kpX = kp.getX();\n    var r = kpX.umod(this.n);\n    if (r.cmpn(0) === 0)\n      continue;\n\n    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n    s = s.umod(this.n);\n    if (s.cmpn(0) === 0)\n      continue;\n\n    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |\n                        (kpX.cmp(r) !== 0 ? 2 : 0);\n\n    // Use complement of `s`, if it is > `n / 2`\n    if (options.canonical && s.cmp(this.nh) > 0) {\n      s = this.n.sub(s);\n      recoveryParam ^= 1;\n    }\n\n    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });\n  }\n};\n\nEC.prototype.verify = function verify(msg, signature, key, enc) {\n  msg = this._truncateToN(new BN(msg, 16));\n  key = this.keyFromPublic(key, enc);\n  signature = new Signature(signature, 'hex');\n\n  // Perform primitive values validation\n  var r = signature.r;\n  var s = signature.s;\n  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)\n    return false;\n  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)\n    return false;\n\n  // Validate signature\n  var sinv = s.invm(this.n);\n  var u1 = sinv.mul(msg).umod(this.n);\n  var u2 = sinv.mul(r).umod(this.n);\n\n  if (!this.curve._maxwellTrick) {\n    var p = this.g.mulAdd(u1, key.getPublic(), u2);\n    if (p.isInfinity())\n      return false;\n\n    return p.getX().umod(this.n).cmp(r) === 0;\n  }\n\n  // NOTE: Greg Maxwell's trick, inspired by:\n  // https://git.io/vad3K\n\n  var p = this.g.jmulAdd(u1, key.getPublic(), u2);\n  if (p.isInfinity())\n    return false;\n\n  // Compare `p.x` of Jacobian point with `r`,\n  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n  // inverse of `p.z^2`\n  return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function(msg, signature, j, enc) {\n  assert((3 & j) === j, 'The recovery param is more than two bits');\n  signature = new Signature(signature, enc);\n\n  var n = this.n;\n  var e = new BN(msg);\n  var r = signature.r;\n  var s = signature.s;\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = j & 1;\n  var isSecondKey = j >> 1;\n  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)\n    throw new Error('Unable to find sencond key candinate');\n\n  // 1.1. Let x = r + jn.\n  if (isSecondKey)\n    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);\n  else\n    r = this.curve.pointFromX(r, isYOdd);\n\n  var rInv = signature.r.invm(n);\n  var s1 = n.sub(e).mul(rInv).umod(n);\n  var s2 = s.mul(rInv).umod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {\n  signature = new Signature(signature, enc);\n  if (signature.recoveryParam !== null)\n    return signature.recoveryParam;\n\n  for (var i = 0; i < 4; i++) {\n    var Qprime;\n    try {\n      Qprime = this.recoverPubKey(e, signature, i);\n    } catch (e) {\n      continue;\n    }\n\n    if (Qprime.eq(Q))\n      return i;\n  }\n  throw new Error('Unable to find valid recovery factor');\n};\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction KeyPair(ec, options) {\n  this.ec = ec;\n  this.priv = null;\n  this.pub = null;\n\n  // KeyPair(ec, { priv: ..., pub: ... })\n  if (options.priv)\n    this._importPrivate(options.priv, options.privEnc);\n  if (options.pub)\n    this._importPublic(options.pub, options.pubEnc);\n}\nmodule.exports = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n  if (pub instanceof KeyPair)\n    return pub;\n\n  return new KeyPair(ec, {\n    pub: pub,\n    pubEnc: enc\n  });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n  if (priv instanceof KeyPair)\n    return priv;\n\n  return new KeyPair(ec, {\n    priv: priv,\n    privEnc: enc\n  });\n};\n\nKeyPair.prototype.validate = function validate() {\n  var pub = this.getPublic();\n\n  if (pub.isInfinity())\n    return { result: false, reason: 'Invalid public key' };\n  if (!pub.validate())\n    return { result: false, reason: 'Public key is not a point' };\n  if (!pub.mul(this.ec.curve.n).isInfinity())\n    return { result: false, reason: 'Public key * N != O' };\n\n  return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n  // compact is optional argument\n  if (typeof compact === 'string') {\n    enc = compact;\n    compact = null;\n  }\n\n  if (!this.pub)\n    this.pub = this.ec.g.mul(this.priv);\n\n  if (!enc)\n    return this.pub;\n\n  return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n  if (enc === 'hex')\n    return this.priv.toString(16, 2);\n  else\n    return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n  this.priv = new BN(key, enc || 16);\n\n  // Ensure that the priv won't be bigger than n, otherwise we may fail\n  // in fixed multiplication method\n  this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n  if (key.x || key.y) {\n    // Montgomery points only have an `x` coordinate.\n    // Weierstrass/Edwards points on the other hand have both `x` and\n    // `y` coordinates.\n    if (this.ec.curve.type === 'mont') {\n      assert(key.x, 'Need x coordinate');\n    } else if (this.ec.curve.type === 'short' ||\n               this.ec.curve.type === 'edwards') {\n      assert(key.x && key.y, 'Need both x and y coordinate');\n    }\n    this.pub = this.ec.curve.point(key.x, key.y);\n    return;\n  }\n  this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n  return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n  return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature) {\n  return this.ec.verify(msg, signature, this);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +\n         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n"],"sourceRoot":""}