upgrades

var NetworkAuthzGranteeAddress = map[string]string{
	pocket.AlphaTestNetChainId: AlphaTestNetPnfAddress,
	pocket.BetaTestNetChainId:  BetaTestNetPnfAddress,

	pocket.MainNetChainId: MainnetGroveAddress,
}

var UpgradeExample = Upgrade{

	PlanName:             "v0.0.0-Example",
	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_10 = Upgrade{
	PlanName: "v0.0.10",
	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		applyNewParameters := func(ctx context.Context) (err error) {

			appParams := keepers.ApplicationKeeper.GetParams(ctx)
			newMinStakeApp := cosmostypes.NewCoin("upokt", math.NewInt(100000000))
			appParams.MinStake = &newMinStakeApp
			err = keepers.ApplicationKeeper.SetParams(ctx, appParams)
			if err != nil {
				return err
			}

			supplierParams := keepers.SupplierKeeper.GetParams(ctx)
			newMinStakeSupplier := cosmostypes.NewCoin("upokt", math.NewInt(1000000))
			supplierParams.MinStake = &newMinStakeSupplier
			err = keepers.SupplierKeeper.SetParams(ctx, supplierParams)
			if err != nil {
				return err
			}

			gatewayParams := keepers.GatewayKeeper.GetParams(ctx)
			newMinStakeGW := cosmostypes.NewCoin("upokt", math.NewInt(1000000))
			gatewayParams.MinStake = &newMinStakeGW
			err = keepers.GatewayKeeper.SetParams(ctx, gatewayParams)
			if err != nil {
				return err
			}

			newProofRequirementThreshold := cosmostypes.NewCoin("upokt", math.NewInt(20000000))
			newProofMissingPenalty := cosmostypes.NewCoin("upokt", math.NewInt(320000000))
			newProofSubmissionFee := cosmostypes.NewCoin("upokt", math.NewInt(1000000))
			proofParams := prooftypes.NewParams(
				0.25,
				&newProofRequirementThreshold,
				&newProofMissingPenalty,
				&newProofSubmissionFee,
			)

			err = keepers.ProofKeeper.SetParams(ctx, proofParams)
			if err != nil {
				return err
			}

			sharedParams := keepers.SharedKeeper.GetParams(ctx)
			sharedParams.SupplierUnbondingPeriodSessions = uint64(1)
			sharedParams.ApplicationUnbondingPeriodSessions = uint64(1)
			sharedParams.ComputeUnitsToTokensMultiplier = uint64(42)
			err = keepers.SharedKeeper.SetParams(ctx, sharedParams)
			if err != nil {
				return err
			}
			return
		}

		applyNewAuthorizations := func(ctx context.Context) (err error) {

			grantAuthorizationMessages := []string{
				"/pocket.gateway.MsgUpdateParam",
				"/pocket.application.MsgUpdateParam",
				"/pocket.supplier.MsgUpdateParam",
			}

			expiration, err := time.Parse(time.RFC3339, "2500-01-01T00:00:00Z")
			if err != nil {
				return fmt.Errorf("failed to parse time: %w", err)
			}

			for _, msg := range grantAuthorizationMessages {
				err = keepers.AuthzKeeper.SaveGrant(
					ctx,
					cosmostypes.AccAddress(AlphaTestNetPnfAddress),
					cosmostypes.AccAddress(AlphaTestNetAuthorityAddress),
					authz.NewGenericAuthorization(msg),
					&expiration,
				)
				if err != nil {
					return fmt.Errorf("failed to save grant for message %s: %w", msg, err)
				}
			}
			return
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			err := applyNewParameters(ctx)
			if err != nil {
				return vm, err
			}

			err = applyNewAuthorizations(ctx)
			if err != nil {
				return vm, err
			}

			return mm.RunMigrations(ctx, configurator, vm)
		}
	},

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_11 = Upgrade{
	PlanName: "v0.0.11",
	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		applyNewParameters := func(ctx context.Context) (err error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting parameter updates for v0.0.11")

			sessionParams := sessiontypes.Params{
				NumSuppliersPerSession: uint64(15),
			}

			err = keepers.SessionKeeper.SetParams(ctx, sessionParams)
			if err != nil {
				logger.Error("Failed to set session params", "error", err)
				return err
			}
			logger.Info("Successfully updated session params", "new_params", sessionParams)

			tokenomicsParams := tokenomicstypes.Params{
				MintAllocationPercentages: tokenomicstypes.MintAllocationPercentages{
					Dao:         0.1,
					Proposer:    0.05,
					Supplier:    0.7,
					SourceOwner: 0.15,
					Application: 0.0,
				},
				DaoRewardAddress: AlphaTestNetPnfAddress,
			}

			err = keepers.TokenomicsKeeper.SetParams(ctx, tokenomicsParams)
			if err != nil {
				logger.Error("Failed to set tokenomics params", "error", err)
				return err
			}
			logger.Info("Successfully updated tokenomics params", "new_params", tokenomicsParams)

			return
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting v0.0.11 upgrade handler")

			err := applyNewParameters(ctx)
			if err != nil {
				logger.Error("Failed to apply new parameters", "error", err)
				return vm, err
			}

			logger.Info("Running module migrations")
			vm, err = mm.RunMigrations(ctx, configurator, vm)
			if err != nil {
				logger.Error("Failed to run migrations", "error", err)
				return vm, err
			}

			logger.Info("Successfully completed v0.0.11 upgrade handler")
			return vm, nil
		}
	},

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_12 = Upgrade{
	PlanName: Upgrade_0_0_12_PlanName,
	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		// Parameter configurations aligned with repository config.yml specifications.
		// These values reflect the delta between v0.0.11 and the main branch as of #1043.
		// Reference:
		// - Comparison: https://github.com/pokt-network/poktroll/compare/v0.0.11..7541afd6d89a12d61e2c32637b535f24fae20b58
		// - Direct diff: `git diff v0.0.11..7541afd6d89a12d61e2c32637b535f24fae20b58 -- config.yml`
		//
		// DEV_NOTE: These parameter updates are derived from config.yml in the root directory
		// of this repository, which serves as the source of truth for all parameter changes.
		const (
			supplierStakingFee                = 1000000 // uPOKT
			serviceTargetNumRelays            = 100     // num relays
			tokenomicsGlobalInflationPerClaim = 0.1     // % of the claim amount
		)

		applyNewParameters := func(ctx context.Context) (err error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting parameter updates", "upgrade_plan_name", Upgrade_0_0_12_PlanName)

			supplierParams := keepers.SupplierKeeper.GetParams(ctx)
			supplierParams.MinStake = &cosmostypes.Coin{
				Denom:  "upokt",
				Amount: math.NewInt(supplierStakingFee),
			}
			err = keepers.SupplierKeeper.SetParams(ctx, supplierParams)
			if err != nil {
				logger.Error("Failed to set supplier params", "error", err)
				return err
			}
			logger.Info("Successfully updated supplier params", "new_params", supplierParams)

			serviceParams := keepers.ServiceKeeper.GetParams(ctx)
			serviceParams.TargetNumRelays = serviceTargetNumRelays
			err = keepers.ServiceKeeper.SetParams(ctx, serviceParams)
			if err != nil {
				logger.Error("Failed to set service params", "error", err)
				return err
			}
			logger.Info("Successfully updated service params", "new_params", serviceParams)

			tokenomicsParams := keepers.TokenomicsKeeper.GetParams(ctx)
			tokenomicsParams.GlobalInflationPerClaim = tokenomicsGlobalInflationPerClaim
			err = keepers.TokenomicsKeeper.SetParams(ctx, tokenomicsParams)
			if err != nil {
				logger.Error("Failed to set tokenomics params", "error", err)
				return err
			}
			logger.Info("Successfully updated tokenomics params", "new_params", tokenomicsParams)
			return nil
		}

		updateSuppliersRevShare := func(ctx context.Context) error {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			suppliers := keepers.SupplierKeeper.GetAllSuppliers(ctx)
			logger.Info("Updating (overriding) all suppliers to delegate 100% revenue share to the supplier's operator address",
				"num_suppliers", len(suppliers))

			for _, supplier := range suppliers {
				for _, service := range supplier.Services {
					if len(service.RevShare) > 1 {

						addresses := make([]string, len(service.RevShare))
						for i, rs := range service.RevShare {
							addresses[i] = rs.Address
						}
						revShareAddressesStr := "[" + strings.Join(addresses, ",") + "]"
						logger.Warn(
							"Overwriting existing revenue share configuration",
							"supplier_operator", supplier.OperatorAddress,
							"supplier_owner", supplier.OwnerAddress,
							"service", service.ServiceId,
							"previous_revshare_count", len(service.RevShare),
							"previous_revshare_addresses", revShareAddressesStr,
						)
						service.RevShare = []*sharedtypes.ServiceRevenueShare{
							{
								Address:            supplier.OperatorAddress,
								RevSharePercentage: uint64(100),
							},
						}
					} else if len(service.RevShare) == 1 {

						logger.Info("Updating supplier's revenue share configuration",
							"supplier_operator", supplier.OperatorAddress,
							"supplier_owner", supplier.OwnerAddress,
							"service", service.ServiceId,
							"previous_revshare_address", service.RevShare[0].Address,
						)
						currentRevShare := service.RevShare[0]
						service.RevShare = []*sharedtypes.ServiceRevenueShare{
							{
								Address:            currentRevShare.Address,
								RevSharePercentage: uint64(100),
							},
						}
					} else {
						logger.Warn("That shouldn't happen: no revenue share configuration found for supplier",
							"supplier_operator", supplier.OperatorAddress,
							"supplier_owner", supplier.OwnerAddress,
							"service", service.ServiceId,
						)
					}
				}
				keepers.SupplierKeeper.SetAndIndexDehydratedSupplier(ctx, supplier)
				logger.Info("Updated supplier",
					"supplier_operator", supplier.OperatorAddress,
					"supplier_owner", supplier.OwnerAddress)
			}
			return nil
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting upgrade handler", "upgrade_plan_name", Upgrade_0_0_12_PlanName)

			logger.Info("Starting parameter updates section", "upgrade_plan_name", Upgrade_0_0_12_PlanName)

			err := applyNewParameters(ctx)
			if err != nil {
				logger.Error("Failed to apply new parameters",
					"upgrade_plan_name", Upgrade_0_0_12_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Starting supplier RevShare updates section", "upgrade_plan_name", Upgrade_0_0_12_PlanName)

			err = updateSuppliersRevShare(ctx)
			if err != nil {
				logger.Error("Failed to update suppliers RevShare",
					"upgrade_plan_name", Upgrade_0_0_12_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Starting module migrations section", "upgrade_plan_name", Upgrade_0_0_12_PlanName)
			vm, err = mm.RunMigrations(ctx, configurator, vm)
			if err != nil {
				logger.Error("Failed to run migrations",
					"upgrade_plan_name", Upgrade_0_0_12_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Successfully completed upgrade handler", "upgrade_plan_name", Upgrade_0_0_12_PlanName)
			return vm, nil
		}
	},

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_13 = Upgrade{
	PlanName: Upgrade_0_0_13_PlanName,
	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		applyNewParameters := func(ctx context.Context) (err error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting parameter updates", "upgrade_plan_name", Upgrade_0_0_13_PlanName)

			sharedParams := keepers.SharedKeeper.GetParams(ctx)
			sharedParams.GatewayUnbondingPeriodSessions = sharedtypes.DefaultGatewayUnbondingPeriodSessions

			if err = sharedParams.ValidateBasic(); err != nil {
				logger.Error("Failed to validate shared params", "error", err)
				return err
			}

			err = keepers.SharedKeeper.SetParams(ctx, sharedParams)
			if err != nil {
				logger.Error("Failed to set shared params", "error", err)
				return err
			}
			logger.Info("Successfully updated shared params", "new_params", sharedParams)

			return nil
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting upgrade handler", "upgrade_plan_name", Upgrade_0_0_13_PlanName)

			logger.Info("Starting parameter updates section", "upgrade_plan_name", Upgrade_0_0_13_PlanName)

			err := applyNewParameters(ctx)
			if err != nil {
				logger.Error("Failed to apply new parameters",
					"upgrade_plan_name", Upgrade_0_0_13_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Starting module migrations section", "upgrade_plan_name", Upgrade_0_0_13_PlanName)
			vm, err = mm.RunMigrations(ctx, configurator, vm)
			if err != nil {
				logger.Error("Failed to run migrations",
					"upgrade_plan_name", Upgrade_0_0_13_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Successfully completed upgrade handler", "upgrade_plan_name", Upgrade_0_0_13_PlanName)
			return vm, nil
		}
	},

	StoreUpgrades: storetypes.StoreUpgrades{

		Added: []string{migrationtypes.StoreKey},
	},
}

var Upgrade_0_0_14 = Upgrade{
	PlanName: Upgrade_0_0_14_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_4 = Upgrade{
	PlanName: "v0.0.4",
	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {

			currentParams, err := keepers.ConsensusParamsKeeper.ParamsStore.Get(ctx)
			if err != nil {
				return vm, err
			}

			newParams := consensusparamtypes.MsgUpdateParams{
				Authority: keepers.ConsensusParamsKeeper.GetAuthority(),
				Block:     currentParams.Block,
				Evidence:  currentParams.Evidence,
				Validator: currentParams.Validator,

				Abci: currentParams.Abci,
			}

			newParams.Block.MaxBytes = 22020096 * 2

			if _, err = keepers.ConsensusParamsKeeper.UpdateParams(ctx, &newParams); err != nil {
				return vm, err
			}

			return mm.RunMigrations(ctx, configurator, vm)
		}
	},

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_0_9 = Upgrade{
	PlanName:             "v0.0.9",
	CreateUpgradeHandler: defaultUpgradeHandler,
	StoreUpgrades:        storetypes.StoreUpgrades{},
}

var Upgrade_0_1_10 = Upgrade{
	PlanName: Upgrade_0_1_10_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_1_11 = Upgrade{
	PlanName: Upgrade_0_1_11_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		applyNewParameters := func(ctx context.Context, logger cosmoslog.Logger) (err error) {
			logger.Info("Starting parameter updates", "upgrade_plan_name", Upgrade_0_1_11_PlanName)

			migrationParams := keepers.MigrationKeeper.GetParams(ctx)

			switch cosmostypes.UnwrapSDKContext(ctx).ChainID() {
			case pocket.AlphaTestNetChainId, pocket.BetaTestNetChainId:
				migrationParams.AllowMorseAccountImportOverwrite = true
			default:
				migrationParams.AllowMorseAccountImportOverwrite = false
			}

			if err = migrationParams.Validate(); err != nil {
				logger.Error("Failed to validate migration params", "error", err)
				return err
			}

			err = keepers.MigrationKeeper.SetParams(ctx, migrationParams)
			if err != nil {
				logger.Error("Failed to set migration params", "error", err)
				return err
			}
			logger.Info("Successfully updated migration params", "new_params", migrationParams)

			return nil
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()

			grantAuthorizationMessages := []string{"/pocket.migration.MsgRecoverMorseAccount"}
			if err := applyNewAuthorizations(ctx, keepers, logger, grantAuthorizationMessages); err != nil {
				return vm, err
			}

			if err := applyNewParameters(ctx, logger); err != nil {
				return vm, err
			}

			return vm, nil
		}
	},
}

var Upgrade_0_1_12 = Upgrade{
	PlanName: Upgrade_0_1_12_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_1_13 = Upgrade{
	PlanName: Upgrade_0_1_13_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		applyComputeUnitsCostGranularity := func(ctx context.Context, logger cosmoslog.Logger) (err error) {
			logger.Info("Starting shared module parameter updates", "upgrade_plan_name", Upgrade_0_1_13_PlanName)

			sharedParams := keepers.SharedKeeper.GetParams(ctx)

			sharedParams.ComputeUnitCostGranularity = 1e6

			sharedParams.ComputeUnitsToTokensMultiplier *= sharedParams.ComputeUnitCostGranularity

			if err = sharedParams.ValidateBasic(); err != nil {
				logger.Error("Failed to validate shared module params", "error", err)
				return err
			}

			err = keepers.SharedKeeper.SetParams(ctx, sharedParams)
			if err != nil {
				logger.Error("Failed to set shared module params", "error", err)
				return err
			}
			logger.Info("Successfully updated shared module params", "new_params", sharedParams)

			return nil
		}

		applyMorseAccountClaimingEnabled := func(ctx context.Context, logger cosmoslog.Logger) (err error) {
			logger.Info("Starting migration module parameter updates", "upgrade_plan_name", Upgrade_0_1_13_PlanName)

			migrationParams := keepers.MigrationKeeper.GetParams(ctx)

			migrationParams.MorseAccountClaimingEnabled = true

			if err = migrationParams.Validate(); err != nil {
				logger.Error("Failed to validate migration module params", "error", err)
				return err
			}

			err = keepers.MigrationKeeper.SetParams(ctx, migrationParams)
			if err != nil {
				logger.Error("Failed to set migration module params", "error", err)
				return err
			}
			logger.Info("Successfully updated migration module params", "new_params", migrationParams)

			return nil
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()

			if err := applyComputeUnitsCostGranularity(ctx, logger); err != nil {
				return vm, err
			}

			if err := applyMorseAccountClaimingEnabled(ctx, logger); err != nil {
				return vm, err
			}

			return vm, nil
		}
	},
}

var Upgrade_0_1_2 = Upgrade{

	PlanName: Upgrade_0_1_2_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		applyNewParameters := func(ctx context.Context) (err error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting parameter updates", "upgrade_plan_name", Upgrade_0_1_2_PlanName)

			migrationParams := migrationtypes.Params{
				WaiveMorseClaimGasFees: true,
			}

			if err = migrationParams.Validate(); err != nil {
				logger.Error("Failed to validate migration params", "error", err)
				return err
			}

			err = keepers.MigrationKeeper.SetParams(ctx, migrationParams)
			if err != nil {
				logger.Error("Failed to set migration params", "error", err)
				return err
			}
			logger.Info("Successfully updated migration params", "new_params", migrationParams)

			return nil
		}

		applyNewAuthorizations := func(ctx context.Context) (err error) {

			grantAuthorizationMessages := []string{
				"/pocket.migration.MsgUpdateParam",
				"/pocket.migration.MsgImportMorseClaimableAccounts",
			}

			expiration, err := time.Parse(time.RFC3339, "2500-01-01T00:00:00Z")
			if err != nil {
				return fmt.Errorf("failed to parse time: %w", err)
			}

			granterAddr := keepers.MigrationKeeper.GetAuthority()

			granteeAddr := NetworkAuthzGranteeAddress[cosmostypes.UnwrapSDKContext(ctx).ChainID()]

			for _, msg := range grantAuthorizationMessages {
				err = keepers.AuthzKeeper.SaveGrant(
					ctx,
					cosmostypes.AccAddress(granteeAddr),
					cosmostypes.AccAddress(granterAddr),
					authz.NewGenericAuthorization(msg),
					&expiration,
				)
				if err != nil {
					return fmt.Errorf("failed to save grant for message %s: %w", msg, err)
				}
			}
			return
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger()
			logger.Info("Starting upgrade handler", "upgrade_plan_name", Upgrade_0_1_2_PlanName)

			err := applyNewParameters(ctx)
			if err != nil {
				logger.Error("Failed to apply new parameters",
					"upgrade_plan_name", Upgrade_0_1_2_PlanName,
					"error", err)
				return vm, err
			}

			err = applyNewAuthorizations(ctx)
			if err != nil {
				logger.Error("Failed to apply new authorizations",
					"upgrade_plan_name", Upgrade_0_1_2_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Starting module migrations section", "upgrade_plan_name", Upgrade_0_1_2_PlanName)
			vm, err = mm.RunMigrations(ctx, configurator, vm)
			if err != nil {
				logger.Error("Failed to run migrations",
					"upgrade_plan_name", Upgrade_0_1_2_PlanName,
					"error", err)
				return vm, err
			}

			logger.Info("Successfully completed upgrade", "upgrade_plan_name", Upgrade_0_1_2_PlanName)
			return vm, nil
		}
	},
}

var Upgrade_0_1_3 = Upgrade{
	PlanName: Upgrade_0_1_3_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_1_4 = Upgrade{

	PlanName: Upgrade_0_1_4_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger().With("upgrade_plan_name", Upgrade_0_1_4_PlanName)
			logger.Info("Starting upgrade handler")

			grantAuthorizationMessages := []string{
				"/pocket.migration.MsgUpdateParams",
				"/pocket.migration.MsgImportMorseClaimableAccounts",
			}

			logger.Info("Starting authorization updates")
			err := applyNewAuthorizations(ctx, keepers, logger, grantAuthorizationMessages)
			if err != nil {
				logger.Error("Failed to apply new authorizations", "error", err)
				return vm, err
			}
			logger.Info("Successfully completed authorization updates")

			logger.Info("Starting module migrations section")
			vm, err = mm.RunMigrations(ctx, configurator, vm)
			if err != nil {
				logger.Error("Failed to run migrations", "error", err)
				return vm, err
			}
			logger.Info("Successfully completed module migrations")

			logger.Info("Successfully completed upgrade")
			return vm, nil
		}
	},
}

var Upgrade_0_1_5 = Upgrade{
	PlanName: Upgrade_0_1_5_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_1_6 = Upgrade{
	PlanName: Upgrade_0_1_6_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

var Upgrade_0_1_7 = Upgrade{
	PlanName: Upgrade_0_1_7_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		newTokenSupplyCoins := cosmostypes.NewCoins(cosmostypes.NewInt64Coin(pocket.DenomMACT, newTokenSupplyAmount))

		mintNewTokenTypeMACT := func(ctx context.Context) (err error) {
			return keepers.BankKeeper.MintCoins(ctx, banktypes.ModuleName, newTokenSupplyCoins)
		}

		distributeNewTokenTypeMACT := func(ctx context.Context) (err error) {
			granteeAddr := NetworkAuthzGranteeAddress[cosmostypes.UnwrapSDKContext(ctx).ChainID()]
			granteeAccAddr := cosmostypes.MustAccAddressFromBech32(granteeAddr)

			return keepers.BankKeeper.SendCoinsFromModuleToAccount(ctx, banktypes.ModuleName, granteeAccAddr, newTokenSupplyCoins)
		}

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			if err := mintNewTokenTypeMACT(ctx); err != nil {
				return vm, err
			}

			if err := distributeNewTokenTypeMACT(ctx); err != nil {
				return vm, err
			}

			return vm, nil
		}
	},
}

var Upgrade_0_1_8 = Upgrade{
	PlanName: Upgrade_0_1_8_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger().With("upgrade_plan_name", Upgrade_0_1_8_PlanName)
			logger.Info("Starting upgrade handler")

			logger.Info("Indexing applications")
			if err := indexApplications(ctx, keepers, logger); err != nil {
				return vm, err
			}

			logger.Info("Indexing suppliers service configs")
			if err := indexSuppliersServiceConfigs(ctx, keepers, logger); err != nil {
				return vm, err
			}

			return vm, nil
		}
	},
}

var Upgrade_0_1_9 = Upgrade{
	PlanName: Upgrade_0_1_9_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			logger := cosmostypes.UnwrapSDKContext(ctx).Logger().With("upgrade_plan_name", Upgrade_0_1_9_PlanName)
			logger.Info("Starting upgrade handler")

			logger.Info("re-indexing suppliers service configs")
			keepers.SupplierKeeper.MigrateSupplierServiceConfigIndexes(ctx)

			return vm, nil
		}
	},
}

var Upgrade_NEXT = Upgrade{
	PlanName: Upgrade_NEXT_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {

		return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
			return vm, nil
		}
	},
}