{"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","checkNew","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","console","log","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","undefined","skipFetchSetup","mode","cache","credentials","redirect","referrer","response","fetch","arrayBuffer","get","statusCode","status","statusMessage","statusText","Uint8Array","staller","duration","setTimeout","bodyify","trim","_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","parseInt","pow","serverError","throttleRetry","race","fetchJson","updated","filter","k","JSON","poll","func","ceiling","interval","retryLimit","oncePoll","once","onceBlock","checkAbstract","words","id","exportWordlist"],"mappings":"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","file":"js/chunk-vendors~0c1c1b47.8e475bce.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        logger.checkNew(new.target, Wallet);\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.6.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.6.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        console.log(error);\n    }\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        console.log(error);\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            console.log(error);\n        }\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.6.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        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}\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    }\n    const reData = new RegExp(\"^data:([a-z0-9-]+/[a-z0-9-]+);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] },\n                body: base64Decode(dataMatch[2])\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.6.0\";\n//# sourceMappingURL=_version.js.map","export const version = \"wordlists/5.6.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":""}