{"version":3,"sources":["webpack:///./node_modules/@ethersproject/wallet/lib.esm/index.js","webpack:///./node_modules/@ethersproject/wallet/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/wordlists/lib.esm/lang-en.js","webpack:///./node_modules/@ethersproject/wordlists/lib.esm/wordlists.js","webpack:///./node_modules/@ethersproject/transactions/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/transactions/lib.esm/index.js","webpack:///./node_modules/@ethersproject/units/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/units/lib.esm/index.js","webpack:///./node_modules/@ethersproject/web/lib.esm/geturl.js","webpack:///./node_modules/@ethersproject/web/lib.esm/index.js","webpack:///./node_modules/@ethersproject/web/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/wordlists/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/wordlists/lib.esm/wordlist.js"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","logger","constructor","privateKey","provider","super","i","address","isAccount","signingKey","d","this","publicKey","throwArgumentError","mnemonic","phrase","hasMnemonic","srcMnemonic","path","locale","node","fromMnemonic","derivePath","isSigningKey","curve","match","length","isProvider","_mnemonic","_signingKey","getAddress","connect","signTransaction","transaction","tx","from","signature","signDigest","signMessage","message","_signTypedData","domain","types","populated","resolveNames","name","throwError","errors","UNSUPPORTED_OPERATION","operation","resolveName","hash","encrypt","password","options","progressCallback","Error","static","entropy","random","extraEntropy","json","account","wordlist","verifyMessage","verifyTypedData","loadWords","lang","replace","toLowerCase","substring","split","check","getWord","index","getWordIndex","word","indexOf","langEn","register","wordlists","en","TransactionTypes","handleAddress","handleNumber","transactionFields","maxLength","numeric","allowedTransactionKeys","chainId","data","gasLimit","gasPrice","nonce","to","type","computeAddress","key","recoverAddress","digest","a","formatNumber","toHexString","accessSetify","addr","storageKeys","map","storageKey","accessListify","Array","isArray","set","Object","keys","reduce","accum","sort","b","localeCompare","formatAccessList","_serializeEip1559","maxFeePerGas","eq","fields","maxPriorityFeePerGas","accessList","sig","push","recoveryParam","r","s","_serializeEip2930","c","raw","forEach","fieldInfo","hexPad","v","Math","floor","pop","_serialize","transactionType","_parseEipSignature","serialize","recid","toNumber","error","parse","rawTransaction","payload","isZero","slice","_parse","_parseEip2930","_parseEip1559","names","commify","comps","String","whole","negative","suffix","formatted","unshift","join","formatUnits","unitName","parseUnits","formatEther","wei","parseEther","ether","getUrl","href","request","method","headers","body","skipFetchSetup","mode","cache","credentials","redirect","referrer","fetchOptions","opts","response","fetch","arrayBuffer","get","statusCode","status","statusMessage","statusText","Uint8Array","staller","duration","setTimeout","bodyify","trim","unpercent","all","code","fromCharCode","parseInt","_fetchData","connection","processFunc","attemptLimit","throttleLimit","assertArgument","throttleCallback","throttleSlotInterval","errorPassThrough","url","allow304","timeout","allowGzip","user","allowInsecureAuthentication","INVALID_ARGUMENT","argument","authorization","base64","reData","RegExp","dataMatch","SERVER_ERROR","requestBody","requestMethod","flatHeaders","header","runningTimeout","timer","promise","makeError","TIMEOUT","cancel","clearTimeout","runningFetch","attempt","location","tryAgain","stall","retryAfter","pow","serverError","throttleRetry","race","fetchJson","updated","filter","k","JSON","processJsonFunc","poll","func","ceiling","interval","retryLimit","oncePoll","once","onceBlock","checkAbstract","words","id","exportWordlist"],"mappings":"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","file":"js/chunk-vendors~0c1c1b47.e9180370.js","sourcesContent":["\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { getAddress } from \"@ethersproject/address\";\nimport { Provider } from \"@ethersproject/abstract-provider\";\nimport { Signer } from \"@ethersproject/abstract-signer\";\nimport { arrayify, concat, hexDataSlice, isHexString, joinSignature } from \"@ethersproject/bytes\";\nimport { hashMessage, _TypedDataEncoder } from \"@ethersproject/hash\";\nimport { defaultPath, HDNode, entropyToMnemonic } from \"@ethersproject/hdnode\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { defineReadOnly, resolveProperties } from \"@ethersproject/properties\";\nimport { randomBytes } from \"@ethersproject/random\";\nimport { SigningKey } from \"@ethersproject/signing-key\";\nimport { decryptJsonWallet, decryptJsonWalletSync, encryptKeystore } from \"@ethersproject/json-wallets\";\nimport { computeAddress, recoverAddress, serialize } from \"@ethersproject/transactions\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nfunction isAccount(value) {\n    return (value != null && isHexString(value.privateKey, 32) && value.address != null);\n}\nfunction hasMnemonic(value) {\n    const mnemonic = value.mnemonic;\n    return (mnemonic && mnemonic.phrase);\n}\nexport class Wallet extends Signer {\n    constructor(privateKey, provider) {\n        super();\n        if (isAccount(privateKey)) {\n            const signingKey = new SigningKey(privateKey.privateKey);\n            defineReadOnly(this, \"_signingKey\", () => signingKey);\n            defineReadOnly(this, \"address\", computeAddress(this.publicKey));\n            if (this.address !== getAddress(privateKey.address)) {\n                logger.throwArgumentError(\"privateKey/address mismatch\", \"privateKey\", \"[REDACTED]\");\n            }\n            if (hasMnemonic(privateKey)) {\n                const srcMnemonic = privateKey.mnemonic;\n                defineReadOnly(this, \"_mnemonic\", () => ({\n                    phrase: srcMnemonic.phrase,\n                    path: srcMnemonic.path || defaultPath,\n                    locale: srcMnemonic.locale || \"en\"\n                }));\n                const mnemonic = this.mnemonic;\n                const node = HDNode.fromMnemonic(mnemonic.phrase, null, mnemonic.locale).derivePath(mnemonic.path);\n                if (computeAddress(node.privateKey) !== this.address) {\n                    logger.throwArgumentError(\"mnemonic/address mismatch\", \"privateKey\", \"[REDACTED]\");\n                }\n            }\n            else {\n                defineReadOnly(this, \"_mnemonic\", () => null);\n            }\n        }\n        else {\n            if (SigningKey.isSigningKey(privateKey)) {\n                /* istanbul ignore if */\n                if (privateKey.curve !== \"secp256k1\") {\n                    logger.throwArgumentError(\"unsupported curve; must be secp256k1\", \"privateKey\", \"[REDACTED]\");\n                }\n                defineReadOnly(this, \"_signingKey\", () => privateKey);\n            }\n            else {\n                // A lot of common tools do not prefix private keys with a 0x (see: #1166)\n                if (typeof (privateKey) === \"string\") {\n                    if (privateKey.match(/^[0-9a-f]*$/i) && privateKey.length === 64) {\n                        privateKey = \"0x\" + privateKey;\n                    }\n                }\n                const signingKey = new SigningKey(privateKey);\n                defineReadOnly(this, \"_signingKey\", () => signingKey);\n            }\n            defineReadOnly(this, \"_mnemonic\", () => null);\n            defineReadOnly(this, \"address\", computeAddress(this.publicKey));\n        }\n        /* istanbul ignore if */\n        if (provider && !Provider.isProvider(provider)) {\n            logger.throwArgumentError(\"invalid provider\", \"provider\", provider);\n        }\n        defineReadOnly(this, \"provider\", provider || null);\n    }\n    get mnemonic() { return this._mnemonic(); }\n    get privateKey() { return this._signingKey().privateKey; }\n    get publicKey() { return this._signingKey().publicKey; }\n    getAddress() {\n        return Promise.resolve(this.address);\n    }\n    connect(provider) {\n        return new Wallet(this, provider);\n    }\n    signTransaction(transaction) {\n        return resolveProperties(transaction).then((tx) => {\n            if (tx.from != null) {\n                if (getAddress(tx.from) !== this.address) {\n                    logger.throwArgumentError(\"transaction from address mismatch\", \"transaction.from\", transaction.from);\n                }\n                delete tx.from;\n            }\n            const signature = this._signingKey().signDigest(keccak256(serialize(tx)));\n            return serialize(tx, signature);\n        });\n    }\n    signMessage(message) {\n        return __awaiter(this, void 0, void 0, function* () {\n            return joinSignature(this._signingKey().signDigest(hashMessage(message)));\n        });\n    }\n    _signTypedData(domain, types, value) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Populate any ENS names\n            const populated = yield _TypedDataEncoder.resolveNames(domain, types, value, (name) => {\n                if (this.provider == null) {\n                    logger.throwError(\"cannot resolve ENS names without a provider\", Logger.errors.UNSUPPORTED_OPERATION, {\n                        operation: \"resolveName\",\n                        value: name\n                    });\n                }\n                return this.provider.resolveName(name);\n            });\n            return joinSignature(this._signingKey().signDigest(_TypedDataEncoder.hash(populated.domain, types, populated.value)));\n        });\n    }\n    encrypt(password, options, progressCallback) {\n        if (typeof (options) === \"function\" && !progressCallback) {\n            progressCallback = options;\n            options = {};\n        }\n        if (progressCallback && typeof (progressCallback) !== \"function\") {\n            throw new Error(\"invalid callback\");\n        }\n        if (!options) {\n            options = {};\n        }\n        return encryptKeystore(this, password, options, progressCallback);\n    }\n    /**\n     *  Static methods to create Wallet instances.\n     */\n    static createRandom(options) {\n        let entropy = randomBytes(16);\n        if (!options) {\n            options = {};\n        }\n        if (options.extraEntropy) {\n            entropy = arrayify(hexDataSlice(keccak256(concat([entropy, options.extraEntropy])), 0, 16));\n        }\n        const mnemonic = entropyToMnemonic(entropy, options.locale);\n        return Wallet.fromMnemonic(mnemonic, options.path, options.locale);\n    }\n    static fromEncryptedJson(json, password, progressCallback) {\n        return decryptJsonWallet(json, password, progressCallback).then((account) => {\n            return new Wallet(account);\n        });\n    }\n    static fromEncryptedJsonSync(json, password) {\n        return new Wallet(decryptJsonWalletSync(json, password));\n    }\n    static fromMnemonic(mnemonic, path, wordlist) {\n        if (!path) {\n            path = defaultPath;\n        }\n        return new Wallet(HDNode.fromMnemonic(mnemonic, null, wordlist).derivePath(path));\n    }\n}\nexport function verifyMessage(message, signature) {\n    return recoverAddress(hashMessage(message), signature);\n}\nexport function verifyTypedData(domain, types, value, signature) {\n    return recoverAddress(_TypedDataEncoder.hash(domain, types, value), signature);\n}\n//# sourceMappingURL=index.js.map","export const version = \"wallet/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { Wordlist } from \"./wordlist\";\nconst words = \"AbandonAbilityAbleAboutAboveAbsentAbsorbAbstractAbsurdAbuseAccessAccidentAccountAccuseAchieveAcidAcousticAcquireAcrossActActionActorActressActualAdaptAddAddictAddressAdjustAdmitAdultAdvanceAdviceAerobicAffairAffordAfraidAgainAgeAgentAgreeAheadAimAirAirportAisleAlarmAlbumAlcoholAlertAlienAllAlleyAllowAlmostAloneAlphaAlreadyAlsoAlterAlwaysAmateurAmazingAmongAmountAmusedAnalystAnchorAncientAngerAngleAngryAnimalAnkleAnnounceAnnualAnotherAnswerAntennaAntiqueAnxietyAnyApartApologyAppearAppleApproveAprilArchArcticAreaArenaArgueArmArmedArmorArmyAroundArrangeArrestArriveArrowArtArtefactArtistArtworkAskAspectAssaultAssetAssistAssumeAsthmaAthleteAtomAttackAttendAttitudeAttractAuctionAuditAugustAuntAuthorAutoAutumnAverageAvocadoAvoidAwakeAwareAwayAwesomeAwfulAwkwardAxisBabyBachelorBaconBadgeBagBalanceBalconyBallBambooBananaBannerBarBarelyBargainBarrelBaseBasicBasketBattleBeachBeanBeautyBecauseBecomeBeefBeforeBeginBehaveBehindBelieveBelowBeltBenchBenefitBestBetrayBetterBetweenBeyondBicycleBidBikeBindBiologyBirdBirthBitterBlackBladeBlameBlanketBlastBleakBlessBlindBloodBlossomBlouseBlueBlurBlushBoardBoatBodyBoilBombBoneBonusBookBoostBorderBoringBorrowBossBottomBounceBoxBoyBracketBrainBrandBrassBraveBreadBreezeBrickBridgeBriefBrightBringBriskBroccoliBrokenBronzeBroomBrotherBrownBrushBubbleBuddyBudgetBuffaloBuildBulbBulkBulletBundleBunkerBurdenBurgerBurstBusBusinessBusyButterBuyerBuzzCabbageCabinCableCactusCageCakeCallCalmCameraCampCanCanalCancelCandyCannonCanoeCanvasCanyonCapableCapitalCaptainCarCarbonCardCargoCarpetCarryCartCaseCashCasinoCastleCasualCatCatalogCatchCategoryCattleCaughtCauseCautionCaveCeilingCeleryCementCensusCenturyCerealCertainChairChalkChampionChangeChaosChapterChargeChaseChatCheapCheckCheeseChefCherryChestChickenChiefChildChimneyChoiceChooseChronicChuckleChunkChurnCigarCinnamonCircleCitizenCityCivilClaimClapClarifyClawClayCleanClerkCleverClickClientCliffClimbClinicClipClockClogCloseClothCloudClownClubClumpClusterClutchCoachCoastCoconutCodeCoffeeCoilCoinCollectColorColumnCombineComeComfortComicCommonCompanyConcertConductConfirmCongressConnectConsiderControlConvinceCookCoolCopperCopyCoralCoreCornCorrectCostCottonCouchCountryCoupleCourseCousinCoverCoyoteCrackCradleCraftCramCraneCrashCraterCrawlCrazyCreamCreditCreekCrewCricketCrimeCrispCriticCropCrossCrouchCrowdCrucialCruelCruiseCrumbleCrunchCrushCryCrystalCubeCultureCupCupboardCuriousCurrentCurtainCurveCushionCustomCuteCycleDadDamageDampDanceDangerDaringDashDaughterDawnDayDealDebateDebrisDecadeDecemberDecideDeclineDecorateDecreaseDeerDefenseDefineDefyDegreeDelayDeliverDemandDemiseDenialDentistDenyDepartDependDepositDepthDeputyDeriveDescribeDesertDesignDeskDespairDestroyDetailDetectDevelopDeviceDevoteDiagramDialDiamondDiaryDiceDieselDietDifferDigitalDignityDilemmaDinnerDinosaurDirectDirtDisagreeDiscoverDiseaseDishDismissDisorderDisplayDistanceDivertDivideDivorceDizzyDoctorDocumentDogDollDolphinDomainDonateDonkeyDonorDoorDoseDoubleDoveDraftDragonDramaDrasticDrawDreamDressDriftDrillDrinkDripDriveDropDrumDryDuckDumbDuneDuringDustDutchDutyDwarfDynamicEagerEagleEarlyEarnEarthEasilyEastEasyEchoEcologyEconomyEdgeEditEducateEffortEggEightEitherElbowElderElectricElegantElementElephantElevatorEliteElseEmbarkEmbodyEmbraceEmergeEmotionEmployEmpowerEmptyEnableEnactEndEndlessEndorseEnemyEnergyEnforceEngageEngineEnhanceEnjoyEnlistEnoughEnrichEnrollEnsureEnterEntireEntryEnvelopeEpisodeEqualEquipEraEraseErodeErosionErrorEruptEscapeEssayEssenceEstateEternalEthicsEvidenceEvilEvokeEvolveExactExampleExcessExchangeExciteExcludeExcuseExecuteExerciseExhaustExhibitExileExistExitExoticExpandExpectExpireExplainExposeExpressExtendExtraEyeEyebrowFabricFaceFacultyFadeFaintFaithFallFalseFameFamilyFamousFanFancyFantasyFarmFashionFatFatalFatherFatigueFaultFavoriteFeatureFebruaryFederalFeeFeedFeelFemaleFenceFestivalFetchFeverFewFiberFictionFieldFigureFileFilmFilterFinalFindFineFingerFinishFireFirmFirstFiscalFishFitFitnessFixFlagFlameFlashFlatFlavorFleeFlightFlipFloatFlockFloorFlowerFluidFlushFlyFoamFocusFogFoilFoldFollowFoodFootForceForestForgetForkFortuneForumForwardFossilFosterFoundFoxFragileFrameFrequentFreshFriendFringeFrogFrontFrostFrownFrozenFruitFuelFunFunnyFurnaceFuryFutureGadgetGainGalaxyGalleryGameGapGarageGarbageGardenGarlicGarmentGasGaspGateGatherGaugeGazeGeneralGeniusGenreGentleGenuineGestureGhostGiantGiftGiggleGingerGiraffeGirlGiveGladGlanceGlareGlassGlideGlimpseGlobeGloomGloryGloveGlowGlueGoatGoddessGoldGoodGooseGorillaGospelGossipGovernGownGrabGraceGrainGrantGrapeGrassGravityGreatGreenGridGriefGritGroceryGroupGrowGruntGuardGuessGuideGuiltGuitarGunGymHabitHairHalfHammerHamsterHandHappyHarborHardHarshHarvestHatHaveHawkHazardHeadHealthHeartHeavyHedgehogHeightHelloHelmetHelpHenHeroHiddenHighHillHintHipHireHistoryHobbyHockeyHoldHoleHolidayHollowHomeHoneyHoodHopeHornHorrorHorseHospitalHostHotelHourHoverHubHugeHumanHumbleHumorHundredHungryHuntHurdleHurryHurtHusbandHybridIceIconIdeaIdentifyIdleIgnoreIllIllegalIllnessImageImitateImmenseImmuneImpactImposeImproveImpulseInchIncludeIncomeIncreaseIndexIndicateIndoorIndustryInfantInflictInformInhaleInheritInitialInjectInjuryInmateInnerInnocentInputInquiryInsaneInsectInsideInspireInstallIntactInterestIntoInvestInviteInvolveIronIslandIsolateIssueItemIvoryJacketJaguarJarJazzJealousJeansJellyJewelJobJoinJokeJourneyJoyJudgeJuiceJumpJungleJuniorJunkJustKangarooKeenKeepKetchupKeyKickKidKidneyKindKingdomKissKitKitchenKiteKittenKiwiKneeKnifeKnockKnowLabLabelLaborLadderLadyLakeLampLanguageLaptopLargeLaterLatinLaughLaundryLavaLawLawnLawsuitLayerLazyLeaderLeafLearnLeaveLectureLeftLegLegalLegendLeisureLemonLendLengthLensLeopardLessonLetterLevelLiarLibertyLibraryLicenseLifeLiftLightLikeLimbLimitLinkLionLiquidListLittleLiveLizardLoadLoanLobsterLocalLockLogicLonelyLongLoopLotteryLoudLoungeLoveLoyalLuckyLuggageLumberLunarLunchLuxuryLyricsMachineMadMagicMagnetMaidMailMainMajorMakeMammalManManageMandateMangoMansionManualMapleMarbleMarchMarginMarineMarketMarriageMaskMassMasterMatchMaterialMathMatrixMatterMaximumMazeMeadowMeanMeasureMeatMechanicMedalMediaMelodyMeltMemberMemoryMentionMenuMercyMergeMeritMerryMeshMessageMetalMethodMiddleMidnightMilkMillionMimicMindMinimumMinorMinuteMiracleMirrorMiseryMissMistakeMixMixedMixtureMobileModelModifyMomMomentMonitorMonkeyMonsterMonthMoonMoralMoreMorningMosquitoMotherMotionMotorMountainMouseMoveMovieMuchMuffinMuleMultiplyMuscleMuseumMushroomMusicMustMutualMyselfMysteryMythNaiveNameNapkinNarrowNastyNationNatureNearNeckNeedNegativeNeglectNeitherNephewNerveNestNetNetworkNeutralNeverNewsNextNiceNightNobleNoiseNomineeNoodleNormalNorthNoseNotableNoteNothingNoticeNovelNowNuclearNumberNurseNutOakObeyObjectObligeObscureObserveObtainObviousOccurOceanOctoberOdorOffOfferOfficeOftenOilOkayOldOliveOlympicOmitOnceOneOnionOnlineOnlyOpenOperaOpinionOpposeOptionOrangeOrbitOrchardOrderOrdinaryOrganOrientOriginalOrphanOstrichOtherOutdoorOuterOutputOutsideOvalOvenOverOwnOwnerOxygenOysterOzonePactPaddlePagePairPalacePalmPandaPanelPanicPantherPaperParadeParentParkParrotPartyPassPatchPathPatientPatrolPatternPausePavePaymentPeacePeanutPearPeasantPelicanPenPenaltyPencilPeoplePepperPerfectPermitPersonPetPhonePhotoPhrasePhysicalPianoPicnicPicturePiecePigPigeonPillPilotPinkPioneerPipePistolPitchPizzaPlacePlanetPlasticPlatePlayPleasePledgePluckPlugPlungePoemPoetPointPolarPolePolicePondPonyPoolPopularPortionPositionPossiblePostPotatoPotteryPovertyPowderPowerPracticePraisePredictPreferPreparePresentPrettyPreventPricePridePrimaryPrintPriorityPrisonPrivatePrizeProblemProcessProduceProfitProgramProjectPromoteProofPropertyProsperProtectProudProvidePublicPuddingPullPulpPulsePumpkinPunchPupilPuppyPurchasePurityPurposePursePushPutPuzzlePyramidQualityQuantumQuarterQuestionQuickQuitQuizQuoteRabbitRaccoonRaceRackRadarRadioRailRainRaiseRallyRampRanchRandomRangeRapidRareRateRatherRavenRawRazorReadyRealReasonRebelRebuildRecallReceiveRecipeRecordRecycleReduceReflectReformRefuseRegionRegretRegularRejectRelaxReleaseReliefRelyRemainRememberRemindRemoveRenderRenewRentReopenRepairRepeatReplaceReportRequireRescueResembleResistResourceResponseResultRetireRetreatReturnReunionRevealReviewRewardRhythmRibRibbonRiceRichRideRidgeRifleRightRigidRingRiotRippleRiskRitualRivalRiverRoadRoastRobotRobustRocketRomanceRoofRookieRoomRoseRotateRoughRoundRouteRoyalRubberRudeRugRuleRunRunwayRuralSadSaddleSadnessSafeSailSaladSalmonSalonSaltSaluteSameSampleSandSatisfySatoshiSauceSausageSaveSayScaleScanScareScatterSceneSchemeSchoolScienceScissorsScorpionScoutScrapScreenScriptScrubSeaSearchSeasonSeatSecondSecretSectionSecuritySeedSeekSegmentSelectSellSeminarSeniorSenseSentenceSeriesServiceSessionSettleSetupSevenShadowShaftShallowShareShedShellSheriffShieldShiftShineShipShiverShockShoeShootShopShortShoulderShoveShrimpShrugShuffleShySiblingSickSideSiegeSightSignSilentSilkSillySilverSimilarSimpleSinceSingSirenSisterSituateSixSizeSkateSketchSkiSkillSkinSkirtSkullSlabSlamSleepSlenderSliceSlideSlightSlimSloganSlotSlowSlushSmallSmartSmileSmokeSmoothSnackSnakeSnapSniffSnowSoapSoccerSocialSockSodaSoftSolarSoldierSolidSolutionSolveSomeoneSongSoonSorrySortSoulSoundSoupSourceSouthSpaceSpareSpatialSpawnSpeakSpecialSpeedSpellSpendSphereSpiceSpiderSpikeSpinSpiritSplitSpoilSponsorSpoonSportSpotSpraySpreadSpringSpySquareSqueezeSquirrelStableStadiumStaffStageStairsStampStandStartStateStaySteakSteelStemStepStereoStickStillStingStockStomachStoneStoolStoryStoveStrategyStreetStrikeStrongStruggleStudentStuffStumbleStyleSubjectSubmitSubwaySuccessSuchSuddenSufferSugarSuggestSuitSummerSunSunnySunsetSuperSupplySupremeSureSurfaceSurgeSurpriseSurroundSurveySuspectSustainSwallowSwampSwapSwarmSwearSweetSwiftSwimSwingSwitchSwordSymbolSymptomSyrupSystemTableTackleTagTailTalentTalkTankTapeTargetTaskTasteTattooTaxiTeachTeamTellTenTenantTennisTentTermTestTextThankThatThemeThenTheoryThereTheyThingThisThoughtThreeThriveThrowThumbThunderTicketTideTigerTiltTimberTimeTinyTipTiredTissueTitleToastTobaccoTodayToddlerToeTogetherToiletTokenTomatoTomorrowToneTongueTonightToolToothTopTopicToppleTorchTornadoTortoiseTossTotalTouristTowardTowerTownToyTrackTradeTrafficTragicTrainTransferTrapTrashTravelTrayTreatTreeTrendTrialTribeTrickTriggerTrimTripTrophyTroubleTruckTrueTrulyTrumpetTrustTruthTryTubeTuitionTumbleTunaTunnelTurkeyTurnTurtleTwelveTwentyTwiceTwinTwistTwoTypeTypicalUglyUmbrellaUnableUnawareUncleUncoverUnderUndoUnfairUnfoldUnhappyUniformUniqueUnitUniverseUnknownUnlockUntilUnusualUnveilUpdateUpgradeUpholdUponUpperUpsetUrbanUrgeUsageUseUsedUsefulUselessUsualUtilityVacantVacuumVagueValidValleyValveVanVanishVaporVariousVastVaultVehicleVelvetVendorVentureVenueVerbVerifyVersionVeryVesselVeteranViableVibrantViciousVictoryVideoViewVillageVintageViolinVirtualVirusVisaVisitVisualVitalVividVocalVoiceVoidVolcanoVolumeVoteVoyageWageWagonWaitWalkWallWalnutWantWarfareWarmWarriorWashWaspWasteWaterWaveWayWealthWeaponWearWeaselWeatherWebWeddingWeekendWeirdWelcomeWestWetWhaleWhatWheatWheelWhenWhereWhipWhisperWideWidthWifeWildWillWinWindowWineWingWinkWinnerWinterWireWisdomWiseWishWitnessWolfWomanWonderWoodWoolWordWorkWorldWorryWorthWrapWreckWrestleWristWriteWrongYardYearYellowYouYoungYouthZebraZeroZoneZoo\";\nlet wordlist = null;\nfunction loadWords(lang) {\n    if (wordlist != null) {\n        return;\n    }\n    wordlist = words.replace(/([A-Z])/g, \" $1\").toLowerCase().substring(1).split(\" \");\n    // Verify the computed list matches the official list\n    /* istanbul ignore if */\n    if (Wordlist.check(lang) !== \"0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60\") {\n        wordlist = null;\n        throw new Error(\"BIP39 Wordlist for en (English) FAILED\");\n    }\n}\nclass LangEn extends Wordlist {\n    constructor() {\n        super(\"en\");\n    }\n    getWord(index) {\n        loadWords(this);\n        return wordlist[index];\n    }\n    getWordIndex(word) {\n        loadWords(this);\n        return wordlist.indexOf(word);\n    }\n}\nconst langEn = new LangEn();\nWordlist.register(langEn);\nexport { langEn };\n//# sourceMappingURL=lang-en.js.map","\"use strict\";\nimport { langEn as en } from \"./lang-en\";\nexport const wordlists = {\n    en: en\n};\n//# sourceMappingURL=wordlists.js.map","export const version = \"transactions/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, hexConcat, hexDataLength, hexDataSlice, hexlify, hexZeroPad, isBytesLike, splitSignature, stripZeros, } from \"@ethersproject/bytes\";\nimport { Zero } from \"@ethersproject/constants\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { checkProperties } from \"@ethersproject/properties\";\nimport * as RLP from \"@ethersproject/rlp\";\nimport { computePublicKey, recoverPublicKey } from \"@ethersproject/signing-key\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport var TransactionTypes;\n(function (TransactionTypes) {\n    TransactionTypes[TransactionTypes[\"legacy\"] = 0] = \"legacy\";\n    TransactionTypes[TransactionTypes[\"eip2930\"] = 1] = \"eip2930\";\n    TransactionTypes[TransactionTypes[\"eip1559\"] = 2] = \"eip1559\";\n})(TransactionTypes || (TransactionTypes = {}));\n;\n///////////////////////////////\nfunction handleAddress(value) {\n    if (value === \"0x\") {\n        return null;\n    }\n    return getAddress(value);\n}\nfunction handleNumber(value) {\n    if (value === \"0x\") {\n        return Zero;\n    }\n    return BigNumber.from(value);\n}\n// Legacy Transaction Fields\nconst transactionFields = [\n    { name: \"nonce\", maxLength: 32, numeric: true },\n    { name: \"gasPrice\", maxLength: 32, numeric: true },\n    { name: \"gasLimit\", maxLength: 32, numeric: true },\n    { name: \"to\", length: 20 },\n    { name: \"value\", maxLength: 32, numeric: true },\n    { name: \"data\" },\n];\nconst allowedTransactionKeys = {\n    chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, type: true, value: true\n};\nexport function computeAddress(key) {\n    const publicKey = computePublicKey(key);\n    return getAddress(hexDataSlice(keccak256(hexDataSlice(publicKey, 1)), 12));\n}\nexport function recoverAddress(digest, signature) {\n    return computeAddress(recoverPublicKey(arrayify(digest), signature));\n}\nfunction formatNumber(value, name) {\n    const result = stripZeros(BigNumber.from(value).toHexString());\n    if (result.length > 32) {\n        logger.throwArgumentError(\"invalid length for \" + name, (\"transaction:\" + name), value);\n    }\n    return result;\n}\nfunction accessSetify(addr, storageKeys) {\n    return {\n        address: getAddress(addr),\n        storageKeys: (storageKeys || []).map((storageKey, index) => {\n            if (hexDataLength(storageKey) !== 32) {\n                logger.throwArgumentError(\"invalid access list storageKey\", `accessList[${addr}:${index}]`, storageKey);\n            }\n            return storageKey.toLowerCase();\n        })\n    };\n}\nexport function accessListify(value) {\n    if (Array.isArray(value)) {\n        return value.map((set, index) => {\n            if (Array.isArray(set)) {\n                if (set.length > 2) {\n                    logger.throwArgumentError(\"access list expected to be [ address, storageKeys[] ]\", `value[${index}]`, set);\n                }\n                return accessSetify(set[0], set[1]);\n            }\n            return accessSetify(set.address, set.storageKeys);\n        });\n    }\n    const result = Object.keys(value).map((addr) => {\n        const storageKeys = value[addr].reduce((accum, storageKey) => {\n            accum[storageKey] = true;\n            return accum;\n        }, {});\n        return accessSetify(addr, Object.keys(storageKeys).sort());\n    });\n    result.sort((a, b) => (a.address.localeCompare(b.address)));\n    return result;\n}\nfunction formatAccessList(value) {\n    return accessListify(value).map((set) => [set.address, set.storageKeys]);\n}\nfunction _serializeEip1559(transaction, signature) {\n    // If there is an explicit gasPrice, make sure it matches the\n    // EIP-1559 fees; otherwise they may not understand what they\n    // think they are setting in terms of fee.\n    if (transaction.gasPrice != null) {\n        const gasPrice = BigNumber.from(transaction.gasPrice);\n        const maxFeePerGas = BigNumber.from(transaction.maxFeePerGas || 0);\n        if (!gasPrice.eq(maxFeePerGas)) {\n            logger.throwArgumentError(\"mismatch EIP-1559 gasPrice != maxFeePerGas\", \"tx\", {\n                gasPrice, maxFeePerGas\n            });\n        }\n    }\n    const fields = [\n        formatNumber(transaction.chainId || 0, \"chainId\"),\n        formatNumber(transaction.nonce || 0, \"nonce\"),\n        formatNumber(transaction.maxPriorityFeePerGas || 0, \"maxPriorityFeePerGas\"),\n        formatNumber(transaction.maxFeePerGas || 0, \"maxFeePerGas\"),\n        formatNumber(transaction.gasLimit || 0, \"gasLimit\"),\n        ((transaction.to != null) ? getAddress(transaction.to) : \"0x\"),\n        formatNumber(transaction.value || 0, \"value\"),\n        (transaction.data || \"0x\"),\n        (formatAccessList(transaction.accessList || []))\n    ];\n    if (signature) {\n        const sig = splitSignature(signature);\n        fields.push(formatNumber(sig.recoveryParam, \"recoveryParam\"));\n        fields.push(stripZeros(sig.r));\n        fields.push(stripZeros(sig.s));\n    }\n    return hexConcat([\"0x02\", RLP.encode(fields)]);\n}\nfunction _serializeEip2930(transaction, signature) {\n    const fields = [\n        formatNumber(transaction.chainId || 0, \"chainId\"),\n        formatNumber(transaction.nonce || 0, \"nonce\"),\n        formatNumber(transaction.gasPrice || 0, \"gasPrice\"),\n        formatNumber(transaction.gasLimit || 0, \"gasLimit\"),\n        ((transaction.to != null) ? getAddress(transaction.to) : \"0x\"),\n        formatNumber(transaction.value || 0, \"value\"),\n        (transaction.data || \"0x\"),\n        (formatAccessList(transaction.accessList || []))\n    ];\n    if (signature) {\n        const sig = splitSignature(signature);\n        fields.push(formatNumber(sig.recoveryParam, \"recoveryParam\"));\n        fields.push(stripZeros(sig.r));\n        fields.push(stripZeros(sig.s));\n    }\n    return hexConcat([\"0x01\", RLP.encode(fields)]);\n}\n// Legacy Transactions and EIP-155\nfunction _serialize(transaction, signature) {\n    checkProperties(transaction, allowedTransactionKeys);\n    const raw = [];\n    transactionFields.forEach(function (fieldInfo) {\n        let value = transaction[fieldInfo.name] || ([]);\n        const options = {};\n        if (fieldInfo.numeric) {\n            options.hexPad = \"left\";\n        }\n        value = arrayify(hexlify(value, options));\n        // Fixed-width field\n        if (fieldInfo.length && value.length !== fieldInfo.length && value.length > 0) {\n            logger.throwArgumentError(\"invalid length for \" + fieldInfo.name, (\"transaction:\" + fieldInfo.name), value);\n        }\n        // Variable-width (with a maximum)\n        if (fieldInfo.maxLength) {\n            value = stripZeros(value);\n            if (value.length > fieldInfo.maxLength) {\n                logger.throwArgumentError(\"invalid length for \" + fieldInfo.name, (\"transaction:\" + fieldInfo.name), value);\n            }\n        }\n        raw.push(hexlify(value));\n    });\n    let chainId = 0;\n    if (transaction.chainId != null) {\n        // A chainId was provided; if non-zero we'll use EIP-155\n        chainId = transaction.chainId;\n        if (typeof (chainId) !== \"number\") {\n            logger.throwArgumentError(\"invalid transaction.chainId\", \"transaction\", transaction);\n        }\n    }\n    else if (signature && !isBytesLike(signature) && signature.v > 28) {\n        // No chainId provided, but the signature is signing with EIP-155; derive chainId\n        chainId = Math.floor((signature.v - 35) / 2);\n    }\n    // We have an EIP-155 transaction (chainId was specified and non-zero)\n    if (chainId !== 0) {\n        raw.push(hexlify(chainId)); // @TODO: hexValue?\n        raw.push(\"0x\");\n        raw.push(\"0x\");\n    }\n    // Requesting an unsigned transaction\n    if (!signature) {\n        return RLP.encode(raw);\n    }\n    // The splitSignature will ensure the transaction has a recoveryParam in the\n    // case that the signTransaction function only adds a v.\n    const sig = splitSignature(signature);\n    // We pushed a chainId and null r, s on for hashing only; remove those\n    let v = 27 + sig.recoveryParam;\n    if (chainId !== 0) {\n        raw.pop();\n        raw.pop();\n        raw.pop();\n        v += chainId * 2 + 8;\n        // If an EIP-155 v (directly or indirectly; maybe _vs) was provided, check it!\n        if (sig.v > 28 && sig.v !== v) {\n            logger.throwArgumentError(\"transaction.chainId/signature.v mismatch\", \"signature\", signature);\n        }\n    }\n    else if (sig.v !== v) {\n        logger.throwArgumentError(\"transaction.chainId/signature.v mismatch\", \"signature\", signature);\n    }\n    raw.push(hexlify(v));\n    raw.push(stripZeros(arrayify(sig.r)));\n    raw.push(stripZeros(arrayify(sig.s)));\n    return RLP.encode(raw);\n}\nexport function serialize(transaction, signature) {\n    // Legacy and EIP-155 Transactions\n    if (transaction.type == null || transaction.type === 0) {\n        if (transaction.accessList != null) {\n            logger.throwArgumentError(\"untyped transactions do not support accessList; include type: 1\", \"transaction\", transaction);\n        }\n        return _serialize(transaction, signature);\n    }\n    // Typed Transactions (EIP-2718)\n    switch (transaction.type) {\n        case 1:\n            return _serializeEip2930(transaction, signature);\n        case 2:\n            return _serializeEip1559(transaction, signature);\n        default:\n            break;\n    }\n    return logger.throwError(`unsupported transaction type: ${transaction.type}`, Logger.errors.UNSUPPORTED_OPERATION, {\n        operation: \"serializeTransaction\",\n        transactionType: transaction.type\n    });\n}\nfunction _parseEipSignature(tx, fields, serialize) {\n    try {\n        const recid = handleNumber(fields[0]).toNumber();\n        if (recid !== 0 && recid !== 1) {\n            throw new Error(\"bad recid\");\n        }\n        tx.v = recid;\n    }\n    catch (error) {\n        logger.throwArgumentError(\"invalid v for transaction type: 1\", \"v\", fields[0]);\n    }\n    tx.r = hexZeroPad(fields[1], 32);\n    tx.s = hexZeroPad(fields[2], 32);\n    try {\n        const digest = keccak256(serialize(tx));\n        tx.from = recoverAddress(digest, { r: tx.r, s: tx.s, recoveryParam: tx.v });\n    }\n    catch (error) { }\n}\nfunction _parseEip1559(payload) {\n    const transaction = RLP.decode(payload.slice(1));\n    if (transaction.length !== 9 && transaction.length !== 12) {\n        logger.throwArgumentError(\"invalid component count for transaction type: 2\", \"payload\", hexlify(payload));\n    }\n    const maxPriorityFeePerGas = handleNumber(transaction[2]);\n    const maxFeePerGas = handleNumber(transaction[3]);\n    const tx = {\n        type: 2,\n        chainId: handleNumber(transaction[0]).toNumber(),\n        nonce: handleNumber(transaction[1]).toNumber(),\n        maxPriorityFeePerGas: maxPriorityFeePerGas,\n        maxFeePerGas: maxFeePerGas,\n        gasPrice: null,\n        gasLimit: handleNumber(transaction[4]),\n        to: handleAddress(transaction[5]),\n        value: handleNumber(transaction[6]),\n        data: transaction[7],\n        accessList: accessListify(transaction[8]),\n    };\n    // Unsigned EIP-1559 Transaction\n    if (transaction.length === 9) {\n        return tx;\n    }\n    tx.hash = keccak256(payload);\n    _parseEipSignature(tx, transaction.slice(9), _serializeEip1559);\n    return tx;\n}\nfunction _parseEip2930(payload) {\n    const transaction = RLP.decode(payload.slice(1));\n    if (transaction.length !== 8 && transaction.length !== 11) {\n        logger.throwArgumentError(\"invalid component count for transaction type: 1\", \"payload\", hexlify(payload));\n    }\n    const tx = {\n        type: 1,\n        chainId: handleNumber(transaction[0]).toNumber(),\n        nonce: handleNumber(transaction[1]).toNumber(),\n        gasPrice: handleNumber(transaction[2]),\n        gasLimit: handleNumber(transaction[3]),\n        to: handleAddress(transaction[4]),\n        value: handleNumber(transaction[5]),\n        data: transaction[6],\n        accessList: accessListify(transaction[7])\n    };\n    // Unsigned EIP-2930 Transaction\n    if (transaction.length === 8) {\n        return tx;\n    }\n    tx.hash = keccak256(payload);\n    _parseEipSignature(tx, transaction.slice(8), _serializeEip2930);\n    return tx;\n}\n// Legacy Transactions and EIP-155\nfunction _parse(rawTransaction) {\n    const transaction = RLP.decode(rawTransaction);\n    if (transaction.length !== 9 && transaction.length !== 6) {\n        logger.throwArgumentError(\"invalid raw transaction\", \"rawTransaction\", rawTransaction);\n    }\n    const tx = {\n        nonce: handleNumber(transaction[0]).toNumber(),\n        gasPrice: handleNumber(transaction[1]),\n        gasLimit: handleNumber(transaction[2]),\n        to: handleAddress(transaction[3]),\n        value: handleNumber(transaction[4]),\n        data: transaction[5],\n        chainId: 0\n    };\n    // Legacy unsigned transaction\n    if (transaction.length === 6) {\n        return tx;\n    }\n    try {\n        tx.v = BigNumber.from(transaction[6]).toNumber();\n    }\n    catch (error) {\n        // @TODO: What makes snese to do? The v is too big\n        return tx;\n    }\n    tx.r = hexZeroPad(transaction[7], 32);\n    tx.s = hexZeroPad(transaction[8], 32);\n    if (BigNumber.from(tx.r).isZero() && BigNumber.from(tx.s).isZero()) {\n        // EIP-155 unsigned transaction\n        tx.chainId = tx.v;\n        tx.v = 0;\n    }\n    else {\n        // Signed Transaction\n        tx.chainId = Math.floor((tx.v - 35) / 2);\n        if (tx.chainId < 0) {\n            tx.chainId = 0;\n        }\n        let recoveryParam = tx.v - 27;\n        const raw = transaction.slice(0, 6);\n        if (tx.chainId !== 0) {\n            raw.push(hexlify(tx.chainId));\n            raw.push(\"0x\");\n            raw.push(\"0x\");\n            recoveryParam -= tx.chainId * 2 + 8;\n        }\n        const digest = keccak256(RLP.encode(raw));\n        try {\n            tx.from = recoverAddress(digest, { r: hexlify(tx.r), s: hexlify(tx.s), recoveryParam: recoveryParam });\n        }\n        catch (error) { }\n        tx.hash = keccak256(rawTransaction);\n    }\n    tx.type = null;\n    return tx;\n}\nexport function parse(rawTransaction) {\n    const payload = arrayify(rawTransaction);\n    // Legacy and EIP-155 Transactions\n    if (payload[0] > 0x7f) {\n        return _parse(payload);\n    }\n    // Typed Transaction (EIP-2718)\n    switch (payload[0]) {\n        case 1:\n            return _parseEip2930(payload);\n        case 2:\n            return _parseEip1559(payload);\n        default:\n            break;\n    }\n    return logger.throwError(`unsupported transaction type: ${payload[0]}`, Logger.errors.UNSUPPORTED_OPERATION, {\n        operation: \"parseTransaction\",\n        transactionType: payload[0]\n    });\n}\n//# sourceMappingURL=index.js.map","export const version = \"units/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { formatFixed, parseFixed } from \"@ethersproject/bignumber\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst names = [\n    \"wei\",\n    \"kwei\",\n    \"mwei\",\n    \"gwei\",\n    \"szabo\",\n    \"finney\",\n    \"ether\",\n];\n// Some environments have issues with RegEx that contain back-tracking, so we cannot\n// use them.\nexport function commify(value) {\n    const comps = String(value).split(\".\");\n    if (comps.length > 2 || !comps[0].match(/^-?[0-9]*$/) || (comps[1] && !comps[1].match(/^[0-9]*$/)) || value === \".\" || value === \"-.\") {\n        logger.throwArgumentError(\"invalid value\", \"value\", value);\n    }\n    // Make sure we have at least one whole digit (0 if none)\n    let whole = comps[0];\n    let negative = \"\";\n    if (whole.substring(0, 1) === \"-\") {\n        negative = \"-\";\n        whole = whole.substring(1);\n    }\n    // Make sure we have at least 1 whole digit with no leading zeros\n    while (whole.substring(0, 1) === \"0\") {\n        whole = whole.substring(1);\n    }\n    if (whole === \"\") {\n        whole = \"0\";\n    }\n    let suffix = \"\";\n    if (comps.length === 2) {\n        suffix = \".\" + (comps[1] || \"0\");\n    }\n    while (suffix.length > 2 && suffix[suffix.length - 1] === \"0\") {\n        suffix = suffix.substring(0, suffix.length - 1);\n    }\n    const formatted = [];\n    while (whole.length) {\n        if (whole.length <= 3) {\n            formatted.unshift(whole);\n            break;\n        }\n        else {\n            const index = whole.length - 3;\n            formatted.unshift(whole.substring(index));\n            whole = whole.substring(0, index);\n        }\n    }\n    return negative + formatted.join(\",\") + suffix;\n}\nexport function formatUnits(value, unitName) {\n    if (typeof (unitName) === \"string\") {\n        const index = names.indexOf(unitName);\n        if (index !== -1) {\n            unitName = 3 * index;\n        }\n    }\n    return formatFixed(value, (unitName != null) ? unitName : 18);\n}\nexport function parseUnits(value, unitName) {\n    if (typeof (value) !== \"string\") {\n        logger.throwArgumentError(\"value must be a string\", \"value\", value);\n    }\n    if (typeof (unitName) === \"string\") {\n        const index = names.indexOf(unitName);\n        if (index !== -1) {\n            unitName = 3 * index;\n        }\n    }\n    return parseFixed(value, (unitName != null) ? unitName : 18);\n}\nexport function formatEther(wei) {\n    return formatUnits(wei, 18);\n}\nexport function parseEther(ether) {\n    return parseUnits(ether, 18);\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { arrayify } from \"@ethersproject/bytes\";\nexport function getUrl(href, options) {\n    return __awaiter(this, void 0, void 0, function* () {\n        if (options == null) {\n            options = {};\n        }\n        const request = {\n            method: (options.method || \"GET\"),\n            headers: (options.headers || {}),\n            body: (options.body || undefined),\n        };\n        if (options.skipFetchSetup !== true) {\n            request.mode = \"cors\"; // no-cors, cors, *same-origin\n            request.cache = \"no-cache\"; // *default, no-cache, reload, force-cache, only-if-cached\n            request.credentials = \"same-origin\"; // include, *same-origin, omit\n            request.redirect = \"follow\"; // manual, *follow, error\n            request.referrer = \"client\"; // no-referrer, *client\n        }\n        ;\n        if (options.fetchOptions != null) {\n            const opts = options.fetchOptions;\n            if (opts.mode) {\n                request.mode = (opts.mode);\n            }\n            if (opts.cache) {\n                request.cache = (opts.cache);\n            }\n            if (opts.credentials) {\n                request.credentials = (opts.credentials);\n            }\n            if (opts.redirect) {\n                request.redirect = (opts.redirect);\n            }\n            if (opts.referrer) {\n                request.referrer = opts.referrer;\n            }\n        }\n        const response = yield fetch(href, request);\n        const body = yield response.arrayBuffer();\n        const headers = {};\n        if (response.headers.forEach) {\n            response.headers.forEach((value, key) => {\n                headers[key.toLowerCase()] = value;\n            });\n        }\n        else {\n            ((response.headers).keys)().forEach((key) => {\n                headers[key.toLowerCase()] = response.headers.get(key);\n            });\n        }\n        return {\n            headers: headers,\n            statusCode: response.status,\n            statusMessage: response.statusText,\n            body: arrayify(new Uint8Array(body)),\n        };\n    });\n}\n//# sourceMappingURL=geturl.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { decode as base64Decode, encode as base64Encode } from \"@ethersproject/base64\";\nimport { hexlify, isBytesLike } from \"@ethersproject/bytes\";\nimport { shallowCopy } from \"@ethersproject/properties\";\nimport { toUtf8Bytes, toUtf8String } from \"@ethersproject/strings\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { getUrl } from \"./geturl\";\nfunction staller(duration) {\n    return new Promise((resolve) => {\n        setTimeout(resolve, duration);\n    });\n}\nfunction bodyify(value, type) {\n    if (value == null) {\n        return null;\n    }\n    if (typeof (value) === \"string\") {\n        return value;\n    }\n    if (isBytesLike(value)) {\n        if (type && (type.split(\"/\")[0] === \"text\" || type.split(\";\")[0].trim() === \"application/json\")) {\n            try {\n                return toUtf8String(value);\n            }\n            catch (error) { }\n            ;\n        }\n        return hexlify(value);\n    }\n    return value;\n}\nfunction unpercent(value) {\n    return toUtf8Bytes(value.replace(/%([0-9a-f][0-9a-f])/gi, (all, code) => {\n        return String.fromCharCode(parseInt(code, 16));\n    }));\n}\n// This API is still a work in progress; the future changes will likely be:\n// - ConnectionInfo => FetchDataRequest<T = any>\n// - FetchDataRequest.body? = string | Uint8Array | { contentType: string, data: string | Uint8Array }\n//   - If string => text/plain, Uint8Array => application/octet-stream (if content-type unspecified)\n// - FetchDataRequest.processFunc = (body: Uint8Array, response: FetchDataResponse) => T\n// For this reason, it should be considered internal until the API is finalized\nexport function _fetchData(connection, body, processFunc) {\n    // How many times to retry in the event of a throttle\n    const attemptLimit = (typeof (connection) === \"object\" && connection.throttleLimit != null) ? connection.throttleLimit : 12;\n    logger.assertArgument((attemptLimit > 0 && (attemptLimit % 1) === 0), \"invalid connection throttle limit\", \"connection.throttleLimit\", attemptLimit);\n    const throttleCallback = ((typeof (connection) === \"object\") ? connection.throttleCallback : null);\n    const throttleSlotInterval = ((typeof (connection) === \"object\" && typeof (connection.throttleSlotInterval) === \"number\") ? connection.throttleSlotInterval : 100);\n    logger.assertArgument((throttleSlotInterval > 0 && (throttleSlotInterval % 1) === 0), \"invalid connection throttle slot interval\", \"connection.throttleSlotInterval\", throttleSlotInterval);\n    const errorPassThrough = ((typeof (connection) === \"object\") ? !!(connection.errorPassThrough) : false);\n    const headers = {};\n    let url = null;\n    // @TODO: Allow ConnectionInfo to override some of these values\n    const options = {\n        method: \"GET\",\n    };\n    let allow304 = false;\n    let timeout = 2 * 60 * 1000;\n    if (typeof (connection) === \"string\") {\n        url = connection;\n    }\n    else if (typeof (connection) === \"object\") {\n        if (connection == null || connection.url == null) {\n            logger.throwArgumentError(\"missing URL\", \"connection.url\", connection);\n        }\n        url = connection.url;\n        if (typeof (connection.timeout) === \"number\" && connection.timeout > 0) {\n            timeout = connection.timeout;\n        }\n        if (connection.headers) {\n            for (const key in connection.headers) {\n                headers[key.toLowerCase()] = { key: key, value: String(connection.headers[key]) };\n                if ([\"if-none-match\", \"if-modified-since\"].indexOf(key.toLowerCase()) >= 0) {\n                    allow304 = true;\n                }\n            }\n        }\n        options.allowGzip = !!connection.allowGzip;\n        if (connection.user != null && connection.password != null) {\n            if (url.substring(0, 6) !== \"https:\" && connection.allowInsecureAuthentication !== true) {\n                logger.throwError(\"basic authentication requires a secure https url\", Logger.errors.INVALID_ARGUMENT, { argument: \"url\", url: url, user: connection.user, password: \"[REDACTED]\" });\n            }\n            const authorization = connection.user + \":\" + connection.password;\n            headers[\"authorization\"] = {\n                key: \"Authorization\",\n                value: \"Basic \" + base64Encode(toUtf8Bytes(authorization))\n            };\n        }\n        if (connection.skipFetchSetup != null) {\n            options.skipFetchSetup = !!connection.skipFetchSetup;\n        }\n        if (connection.fetchOptions != null) {\n            options.fetchOptions = shallowCopy(connection.fetchOptions);\n        }\n    }\n    const reData = new RegExp(\"^data:([^;:]*)?(;base64)?,(.*)$\", \"i\");\n    const dataMatch = ((url) ? url.match(reData) : null);\n    if (dataMatch) {\n        try {\n            const response = {\n                statusCode: 200,\n                statusMessage: \"OK\",\n                headers: { \"content-type\": (dataMatch[1] || \"text/plain\") },\n                body: (dataMatch[2] ? base64Decode(dataMatch[3]) : unpercent(dataMatch[3]))\n            };\n            let result = response.body;\n            if (processFunc) {\n                result = processFunc(response.body, response);\n            }\n            return Promise.resolve(result);\n        }\n        catch (error) {\n            logger.throwError(\"processing response error\", Logger.errors.SERVER_ERROR, {\n                body: bodyify(dataMatch[1], dataMatch[2]),\n                error: error,\n                requestBody: null,\n                requestMethod: \"GET\",\n                url: url\n            });\n        }\n    }\n    if (body) {\n        options.method = \"POST\";\n        options.body = body;\n        if (headers[\"content-type\"] == null) {\n            headers[\"content-type\"] = { key: \"Content-Type\", value: \"application/octet-stream\" };\n        }\n        if (headers[\"content-length\"] == null) {\n            headers[\"content-length\"] = { key: \"Content-Length\", value: String(body.length) };\n        }\n    }\n    const flatHeaders = {};\n    Object.keys(headers).forEach((key) => {\n        const header = headers[key];\n        flatHeaders[header.key] = header.value;\n    });\n    options.headers = flatHeaders;\n    const runningTimeout = (function () {\n        let timer = null;\n        const promise = new Promise(function (resolve, reject) {\n            if (timeout) {\n                timer = setTimeout(() => {\n                    if (timer == null) {\n                        return;\n                    }\n                    timer = null;\n                    reject(logger.makeError(\"timeout\", Logger.errors.TIMEOUT, {\n                        requestBody: bodyify(options.body, flatHeaders[\"content-type\"]),\n                        requestMethod: options.method,\n                        timeout: timeout,\n                        url: url\n                    }));\n                }, timeout);\n            }\n        });\n        const cancel = function () {\n            if (timer == null) {\n                return;\n            }\n            clearTimeout(timer);\n            timer = null;\n        };\n        return { promise, cancel };\n    })();\n    const runningFetch = (function () {\n        return __awaiter(this, void 0, void 0, function* () {\n            for (let attempt = 0; attempt < attemptLimit; attempt++) {\n                let response = null;\n                try {\n                    response = yield getUrl(url, options);\n                    if (attempt < attemptLimit) {\n                        if (response.statusCode === 301 || response.statusCode === 302) {\n                            // Redirection; for now we only support absolute locataions\n                            const location = response.headers.location || \"\";\n                            if (options.method === \"GET\" && location.match(/^https:/)) {\n                                url = response.headers.location;\n                                continue;\n                            }\n                        }\n                        else if (response.statusCode === 429) {\n                            // Exponential back-off throttling\n                            let tryAgain = true;\n                            if (throttleCallback) {\n                                tryAgain = yield throttleCallback(attempt, url);\n                            }\n                            if (tryAgain) {\n                                let stall = 0;\n                                const retryAfter = response.headers[\"retry-after\"];\n                                if (typeof (retryAfter) === \"string\" && retryAfter.match(/^[1-9][0-9]*$/)) {\n                                    stall = parseInt(retryAfter) * 1000;\n                                }\n                                else {\n                                    stall = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));\n                                }\n                                //console.log(\"Stalling 429\");\n                                yield staller(stall);\n                                continue;\n                            }\n                        }\n                    }\n                }\n                catch (error) {\n                    response = error.response;\n                    if (response == null) {\n                        runningTimeout.cancel();\n                        logger.throwError(\"missing response\", Logger.errors.SERVER_ERROR, {\n                            requestBody: bodyify(options.body, flatHeaders[\"content-type\"]),\n                            requestMethod: options.method,\n                            serverError: error,\n                            url: url\n                        });\n                    }\n                }\n                let body = response.body;\n                if (allow304 && response.statusCode === 304) {\n                    body = null;\n                }\n                else if (!errorPassThrough && (response.statusCode < 200 || response.statusCode >= 300)) {\n                    runningTimeout.cancel();\n                    logger.throwError(\"bad response\", Logger.errors.SERVER_ERROR, {\n                        status: response.statusCode,\n                        headers: response.headers,\n                        body: bodyify(body, ((response.headers) ? response.headers[\"content-type\"] : null)),\n                        requestBody: bodyify(options.body, flatHeaders[\"content-type\"]),\n                        requestMethod: options.method,\n                        url: url\n                    });\n                }\n                if (processFunc) {\n                    try {\n                        const result = yield processFunc(body, response);\n                        runningTimeout.cancel();\n                        return result;\n                    }\n                    catch (error) {\n                        // Allow the processFunc to trigger a throttle\n                        if (error.throttleRetry && attempt < attemptLimit) {\n                            let tryAgain = true;\n                            if (throttleCallback) {\n                                tryAgain = yield throttleCallback(attempt, url);\n                            }\n                            if (tryAgain) {\n                                const timeout = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));\n                                //console.log(\"Stalling callback\");\n                                yield staller(timeout);\n                                continue;\n                            }\n                        }\n                        runningTimeout.cancel();\n                        logger.throwError(\"processing response error\", Logger.errors.SERVER_ERROR, {\n                            body: bodyify(body, ((response.headers) ? response.headers[\"content-type\"] : null)),\n                            error: error,\n                            requestBody: bodyify(options.body, flatHeaders[\"content-type\"]),\n                            requestMethod: options.method,\n                            url: url\n                        });\n                    }\n                }\n                runningTimeout.cancel();\n                // If we had a processFunc, it either returned a T or threw above.\n                // The \"body\" is now a Uint8Array.\n                return body;\n            }\n            return logger.throwError(\"failed response\", Logger.errors.SERVER_ERROR, {\n                requestBody: bodyify(options.body, flatHeaders[\"content-type\"]),\n                requestMethod: options.method,\n                url: url\n            });\n        });\n    })();\n    return Promise.race([runningTimeout.promise, runningFetch]);\n}\nexport function fetchJson(connection, json, processFunc) {\n    let processJsonFunc = (value, response) => {\n        let result = null;\n        if (value != null) {\n            try {\n                result = JSON.parse(toUtf8String(value));\n            }\n            catch (error) {\n                logger.throwError(\"invalid JSON\", Logger.errors.SERVER_ERROR, {\n                    body: value,\n                    error: error\n                });\n            }\n        }\n        if (processFunc) {\n            result = processFunc(result, response);\n        }\n        return result;\n    };\n    // If we have json to send, we must\n    // - add content-type of application/json (unless already overridden)\n    // - convert the json to bytes\n    let body = null;\n    if (json != null) {\n        body = toUtf8Bytes(json);\n        // Create a connection with the content-type set for JSON\n        const updated = (typeof (connection) === \"string\") ? ({ url: connection }) : shallowCopy(connection);\n        if (updated.headers) {\n            const hasContentType = (Object.keys(updated.headers).filter((k) => (k.toLowerCase() === \"content-type\")).length) !== 0;\n            if (!hasContentType) {\n                updated.headers = shallowCopy(updated.headers);\n                updated.headers[\"content-type\"] = \"application/json\";\n            }\n        }\n        else {\n            updated.headers = { \"content-type\": \"application/json\" };\n        }\n        connection = updated;\n    }\n    return _fetchData(connection, body, processJsonFunc);\n}\nexport function poll(func, options) {\n    if (!options) {\n        options = {};\n    }\n    options = shallowCopy(options);\n    if (options.floor == null) {\n        options.floor = 0;\n    }\n    if (options.ceiling == null) {\n        options.ceiling = 10000;\n    }\n    if (options.interval == null) {\n        options.interval = 250;\n    }\n    return new Promise(function (resolve, reject) {\n        let timer = null;\n        let done = false;\n        // Returns true if cancel was successful. Unsuccessful cancel means we're already done.\n        const cancel = () => {\n            if (done) {\n                return false;\n            }\n            done = true;\n            if (timer) {\n                clearTimeout(timer);\n            }\n            return true;\n        };\n        if (options.timeout) {\n            timer = setTimeout(() => {\n                if (cancel()) {\n                    reject(new Error(\"timeout\"));\n                }\n            }, options.timeout);\n        }\n        const retryLimit = options.retryLimit;\n        let attempt = 0;\n        function check() {\n            return func().then(function (result) {\n                // If we have a result, or are allowed null then we're done\n                if (result !== undefined) {\n                    if (cancel()) {\n                        resolve(result);\n                    }\n                }\n                else if (options.oncePoll) {\n                    options.oncePoll.once(\"poll\", check);\n                }\n                else if (options.onceBlock) {\n                    options.onceBlock.once(\"block\", check);\n                    // Otherwise, exponential back-off (up to 10s) our next request\n                }\n                else if (!done) {\n                    attempt++;\n                    if (attempt > retryLimit) {\n                        if (cancel()) {\n                            reject(new Error(\"retry limit reached\"));\n                        }\n                        return;\n                    }\n                    let timeout = options.interval * parseInt(String(Math.random() * Math.pow(2, attempt)));\n                    if (timeout < options.floor) {\n                        timeout = options.floor;\n                    }\n                    if (timeout > options.ceiling) {\n                        timeout = options.ceiling;\n                    }\n                    setTimeout(check, timeout);\n                }\n                return null;\n            }, function (error) {\n                if (cancel()) {\n                    reject(error);\n                }\n            });\n        }\n        check();\n    });\n}\n//# sourceMappingURL=index.js.map","export const version = \"web/5.7.1\";\n//# sourceMappingURL=_version.js.map","export const version = \"wordlists/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\n// This gets overridden by rollup\nconst exportWordlist = false;\nimport { id } from \"@ethersproject/hash\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nexport const logger = new Logger(version);\nexport class Wordlist {\n    constructor(locale) {\n        logger.checkAbstract(new.target, Wordlist);\n        defineReadOnly(this, \"locale\", locale);\n    }\n    // Subclasses may override this\n    split(mnemonic) {\n        return mnemonic.toLowerCase().split(/ +/g);\n    }\n    // Subclasses may override this\n    join(words) {\n        return words.join(\" \");\n    }\n    static check(wordlist) {\n        const words = [];\n        for (let i = 0; i < 2048; i++) {\n            const word = wordlist.getWord(i);\n            /* istanbul ignore if */\n            if (i !== wordlist.getWordIndex(word)) {\n                return \"0x\";\n            }\n            words.push(word);\n        }\n        return id(words.join(\"\\n\") + \"\\n\");\n    }\n    static register(lang, name) {\n        if (!name) {\n            name = lang.locale;\n        }\n        /* istanbul ignore if */\n        if (exportWordlist) {\n            try {\n                const anyGlobal = window;\n                if (anyGlobal._ethers && anyGlobal._ethers.wordlists) {\n                    if (!anyGlobal._ethers.wordlists[name]) {\n                        defineReadOnly(anyGlobal._ethers.wordlists, name, lang);\n                    }\n                }\n            }\n            catch (error) { }\n        }\n    }\n}\n//# sourceMappingURL=wordlist.js.map"],"sourceRoot":""}