upgrades

Documentation

Overview

vNEXT_Template.go - Canonical Upgrade Template

──────────────────────────────────────────────────────────────── TEMPLATE PURPOSE:

• This file is the canonical TEMPLATE for all future onchain upgrade files in the poktroll repo.
• DO NOT add upgrade-specific logic or changes to this file.
• YOU SHOULD NEVER NEED TO CHANGE THIS FILE

USAGE INSTRUCTIONS:

1. To start a new upgrade cycle, rename vNEXT.go to the target version (e.g., v0.1.14.go) and update all identifiers accordingly: cp ./app/upgrades/vNEXT.go ./app/upgrades/v0.1.14.go
2. Then, copy this file to vNEXT.go: cp ./app/upgrades/vNEXT_Template.go ./app/upgrades/vNEXT.go
3. Look for the word "Template" in `vNEXT.go` and replace it with an empty string.
4. Make all upgrade-specific changes in vNEXT.go only.
5. To reset, restore, or start a new upgrade cycle, repeat from step 1.
6. Update the last entry in the `allUpgrades` slice in `app/upgrades.go` to point to the new upgrade version variable.

vNEXT_Template.go should NEVER be modified for upgrade-specific logic. Only update this file to improve the template itself.

See also: https://github.com/pokt-network/poktroll/compare/vPREV..vNEXT

────────────────────────────────────────────────────────────────

Index

• Constants
• Variables
• type Upgrade

Constants

const (
	// Useful for local testing & development
	LocalNetPnfAddress = "pokt1eeeksh2tvkh7wzmfrljnhw4wrhs55lcuvmekkw"

	// The default PNF/DAO address in the genesis file for Alpha TestNet. Used to create new authz authorizations.
	AlphaTestNetPnfAddress = "pokt1r6ja6rz6rpae58njfrsgs5n5sp3r36r2q9j04h"

	// This is the authority address used to create new authz authorizations. Defaults to x/gov module account address.
	// DEV_NOTE: This hard-coded address is kept for record-keeping historical purposes.
	// Use `keepers.<target_module>.GetAuthority()` to get the authority address for the module.
	AlphaTestNetAuthorityAddress = "pokt10d07y265gmmuvt4z0w9aw880jnsr700j8yv32t"

	// The default PNF/DAO address in the genesis file for Beta TestNet. Used to create new authz authorizations.
	BetaTestNetPnfAddress = "pokt1f0c9y7mahf2ya8tymy8g4rr75ezh3pkklu4c3e"

	// PNF/DAO address specified in MainNet genesis.
	// Used to create new authz authorizations after migration is complete.
	MainNetPnfAddress = "pokt1hv3xrylxvwd7hfv03j50ql0ttp3s5hqqelegmv"

	// Grove address specified in MainNet genesis.
	// Used to create new authz authorizations throughout the migration process.
	MainnetGroveAddress = "pokt18808wvw0h4t450t06uvauny8lvscsxjfyua7vh"
)

Visit the pocket-network-genesis repo for the source of truth for these addresses. https://github.com/pokt-network/pocket-network-genesis/tree/master/shannon

const (
	// BlockTimeAdjustmentFactor adds a safety margin to estimated block time
	// for calculating IBC parameters:
	// - ibc.connection.params.max_expected_time_per_block
	// - ibc.channel.params.upgrade_timeout.timestamp
	BlockTimeAdjustmentFactor = 1.5

	// IBC channel upgrade timeout revision settings
	IbcChannelParamUpgradeTimeoutRevisionNumber = uint64(0)
	IbcChannelParamUpgradeTimeoutRevisionHeight = uint64(0)

	// IBC transfer settings
	IbcTransferParamSendEnabled    = true
	IbcTransferParamReceiveEnabled = true

	// ICA (Interchain Accounts) settings
	// Ref: https://ibc.cosmos.network/v8/apps/interchain-accounts/parameters/
	IbcIcaHostParamHostEnabled             = true
	IbcIcaControllerParamControllerEnabled = true
)

const Upgrade_0_0_12_PlanName = "v0.0.12"

const Upgrade_0_0_13_PlanName = "v0.0.13"

const Upgrade_0_0_14_PlanName = "v0.0.14"

const Upgrade_0_1_10_PlanName = "v0.1.10"

const (
	Upgrade_0_1_11_PlanName = "v0.1.11"
)

const (
	Upgrade_0_1_12_PlanName = "v0.1.12"
)

const (
	Upgrade_0_1_13_PlanName = "v0.1.13"
)

const (
	Upgrade_0_1_14_PlanName = "v0.1.14"
)

const (
	Upgrade_0_1_15_PlanName = "v0.1.15"
)

const (
	Upgrade_0_1_16_PlanName = "v0.1.16"
)

const (
	Upgrade_0_1_17_PlanName = "v0.1.17"
)

const (
	Upgrade_0_1_18_PlanName = "v0.1.18"
)

const (
	Upgrade_0_1_19_PlanName = "v0.1.19"
)

const (
	Upgrade_0_1_20_PlanName = "v0.1.20"
)

const (
	Upgrade_0_1_21_PlanName = "v0.1.21"
)

const (
	Upgrade_0_1_22_PlanName = "v0.1.22"
)

const (
	Upgrade_0_1_23_PlanName = "v0.1.23"
)

const (
	Upgrade_0_1_24_PlanName = "v0.1.24"
)

const (
	Upgrade_0_1_25_PlanName = "v0.1.25"
)

const (
	Upgrade_0_1_26_PlanName = "v0.1.26"
)

const (
	Upgrade_0_1_27_PlanName = "v0.1.27"
)

const (
	Upgrade_0_1_28_PlanName = "v0.1.28"
)

const (
	Upgrade_0_1_29_PlanName = "v0.1.29"
)

const Upgrade_0_1_2_PlanName = "v0.1.2"

const (
	Upgrade_0_1_30_PlanName = "v0.1.30"
)

const (
	Upgrade_0_1_31_Beta_2_PlanName = "v0.1.31-beta-2"
)

const (
	Upgrade_0_1_31_PlanName = "v0.1.31"
)

const (
	Upgrade_0_1_33_PlanName = "v0.1.33"
)

const Upgrade_0_1_3_PlanName = "v0.1.3"

const Upgrade_0_1_4_PlanName = "v0.1.4"

const Upgrade_0_1_5_PlanName = "v0.1.5"

const Upgrade_0_1_6_PlanName = "v0.1.6"

const (
	Upgrade_0_1_7_PlanName = "v0.1.7"
)

const (
	Upgrade_0_1_8_PlanName = "v0.1.8"
)

const Upgrade_0_1_9_PlanName = "v0.1.9"

const (
	Upgrade_NEXTTemplate_PlanName = "vNEXT"
)

const (
	Upgrade_NEXT_PlanName = "vNEXT"
)

Variables

var (
	// Allowed IBC client types
	// Ref: https://ibc.cosmos.network/params/params.md/
	IbcClientParamAllowedClients = []string{"07-tendermint"}

	// Allow all message types for ICA execution
	IbcIcaHostParamAllowMessages = []string{"*"}
)

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

	pocket.MainNetChainId: MainnetGroveAddress,
}

NetworkAuthzGranteeAddress is a map of network names (i.e chain-id) to their respective authorization (i.e. PNF/DAO) addresses.

var UpgradeExample = Upgrade{

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

	StoreUpgrades: storetypes.StoreUpgrades{},
}

An example of an upgrade that uses the default upgrade handler and also performs additional state changes. For example, even if `ConsensusVersion` is not modified for any modules, it still might be beneficial to create an upgrade so node runners are signaled to start utilizing `Cosmovisor` for new binaries.

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{},
}

Upgrade_0_0_10 is the upgrade handler for v0.0.10 Alpha TestNet upgrade Before/after validations should be done using the correct version, mimiching real-world scenario:

• Before: v0.0.9
• After: v0.0.10

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{},
}

Upgrade_0_0_11 is the upgrade handler for v0.0.11 Alpha TestNet upgrade Beta TestNet was launched with v0.0.11, so this upgrade is exclusively for Alpha TestNet.

• Before: v0.0.10
• After: v0.0.11

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{},
}

Upgrade_0_0_12 handles the upgrade to release `v0.0.12`. This is planned to be issued on both Pocket Network's Shannon Alpha & Beta TestNets.

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},
	},
}

Upgrade_0_0_13 handles the upgrade to release `v0.0.13`. This is planned to be issued on both Pocket Network's Shannon Alpha & Beta TestNets.

var Upgrade_0_0_14 = Upgrade{
	PlanName: Upgrade_0_0_14_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_0_14 handles the upgrade to release `v0.0.14`. This is planned to be issued on both Pocket Network's Shannon Alpha & Beta TestNets.

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{},
}

Upgrade_0_0_4 is an example of an upgrade that increases the block size. This example demonstrates how to change the block size using an upgrade.

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

Upgrade_0_0_9 is a small upgrade on TestNet.

var Upgrade_0_1_10 = Upgrade{
	PlanName: Upgrade_0_1_10_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_1_9 handles the upgrade to release `v0.1.9`. This is fix upgrade to be issued on both Pocket Network's Shannon Alpha, Beta TestNets. It is an upgrade intended to fix chain halts caused by the previous upgrade. https://github.com/pokt-network/poktroll/compare/v0.1.9..v0.1.10

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
		}
	},
}

Upgrade_0_1_11 handles the upgrade to release `v0.1.11`. This upgrade adds: - the `allow_morse_account_import_overwrite` migration module param

• Set to `false` by default
• Set to `true` on Alpha and Beta TestNets

- a corresponding authz grant - new `MsgRecoverMorseAccount` message with empty message handlers (scaffolding) https://github.com/pokt-network/poktroll/compare/v0.1.10..v0.1.11

var Upgrade_0_1_12 = Upgrade{
	PlanName: Upgrade_0_1_12_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_1_12 handles the upgrade to release `v0.1.12`. https://github.com/pokt-network/poktroll/compare/v0.1.11..v0.1.12

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
		}
	},
}

Upgrade_0_1_13 handles the upgrade to release `v0.1.13`. This upgrade: - Adds the `compute_unit_cost_granularity` shared module param - Adds the `morse_account_claiming_enabled` migration module param - Fixes chain halt caused by zero relay claims

https://github.com/pokt-network/poktroll/compare/v0.1.12..v0.1.13

var Upgrade_0_1_14 = Upgrade{
	PlanName: Upgrade_0_1_14_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
		}
	},
}

Upgrade_0_1_14 handles the upgrade to release `v0.1.14`. This upgrade has no state migrations, it only releases new onchain features: - Add Morse supplier claiming non-custodial Morse owner check (#1317)

var Upgrade_0_1_15 = Upgrade{
	PlanName: Upgrade_0_1_15_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
		}
	},
}

Upgrade_0_1_15 handles the upgrade to release `v0.1.15`. This upgrade has no state migrations, it only releases new onchain features: - Add compute units validation in claim settlement to prevent chain halts when CUPR params change (#1407)

var Upgrade_0_1_16 = Upgrade{
	PlanName: Upgrade_0_1_16_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()

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

			return vm, nil
		}
	},
}

Upgrade_0_1_16 handles the upgrade to release `v0.1.16`. - Normalize Morse accounts recovery allowlist addresses (to uppercase). - Normalize Morse source address when handling Morse account recovery message.

var Upgrade_0_1_17 = Upgrade{
	PlanName: Upgrade_0_1_17_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
		}
	},
}

Upgrade_0_1_17 handles the upgrade to release `v0.1.17`. This upgrade adds: - Fix for non-deterministic behavior in the unstaking of Morse suppliers

var Upgrade_0_1_18 = Upgrade{
	PlanName: Upgrade_0_1_18_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
		}
	},
}

Upgrade_0_1_18 handles the upgrade to release `v0.1.18`. This upgrade adds: - Updates the Morse recoverable account allowlists

var Upgrade_0_1_19 = Upgrade{
	PlanName: Upgrade_0_1_19_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
		}
	},
}

Upgrade_0_1_19 handles the upgrade to release `v0.1.19`. This upgrade adds: - Fix claiming Morse supplier that's fully unstaked

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
		}
	},
}

Upgrade_0_1_2 handles the upgrade to release `v0.1.2`. This is planned to be issued on both Pocket Network's Shannon Alpha & Beta TestNets as well as Mainnet.

var Upgrade_0_1_20 = Upgrade{
	PlanName: Upgrade_0_1_20_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

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

		createZeroBalanceMorseClaimableAccounts := func(ctx context.Context) error {
			sdkCtx := sdk.UnwrapSDKContext(ctx)
			var zeroBalanceMorseClaimableAccounts []*migrationtypes.MorseClaimableAccount

			if err := json.Unmarshal(mainNetZeroBalanceMorseClaimableAccountsJSONBZ, &zeroBalanceMorseClaimableAccounts); err != nil {
				return err
			}

			if sdkCtx.ChainID() != pocket.MainNetChainId {
				var testNetZeroBalanceMorseClaimableAccounts []*migrationtypes.MorseClaimableAccount
				if err := json.Unmarshal(testNetZeroBalanceMorseClaimableAccountsJSONBZ, &testNetZeroBalanceMorseClaimableAccounts); err != nil {
					return err
				}

				zeroBalanceMorseClaimableAccounts = append(zeroBalanceMorseClaimableAccounts, testNetZeroBalanceMorseClaimableAccounts...)
			}

			for _, morseClaimableAccount := range zeroBalanceMorseClaimableAccounts {

				if _, isFound := keepers.MigrationKeeper.GetMorseClaimableAccount(ctx, morseClaimableAccount.GetMorseSrcAddress()); isFound {
					continue
				}

				keepers.MigrationKeeper.SetMorseClaimableAccount(ctx, *morseClaimableAccount)
			}

			return nil
		}

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

			return vm, nil
		}
	},
}

Upgrade_0_1_20 handles the upgrade to release `v0.1.20`. This upgrade adds: 1. Creation of zero-balance/stake `MorseClaimableAccount`s for Morse owner accounts that:

• Are non-custodial
• Had no corresponding `MorseAuthAccount` because they were never used (no balance, no onchain public key)
• Were therefore excluded from the canonical `MsgImportMorseClaimableAccounts` import. There is **zero risk** of unintended token minting (staked or unstaked).

2. Update the Morse account recovery allowlist:

• Add all known invalid addresses
• Update the exchanges allowlist

var Upgrade_0_1_21 = Upgrade{
	PlanName: Upgrade_0_1_21_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
		}
	},
}

Upgrade_0_1_21 handles the upgrade to release `v0.1.21`. This upgrade adds:

1. Update the recovery allowlist to include the additional accounts
2. Slim down excessively sized proof module events: - Changes multiple event protobuf types. - Nodes syncing from genesis will run distinct binaries and swap them at the respective onchain upgrade heights—no state migration required. - WILL impact offchain observers who consume/operate on historical data. - Proper protobuf type (pkg-level) versioning is required to mitigate this. - See: https://github.com/pokt-network/poktroll/issues/1517.

var Upgrade_0_1_22 = Upgrade{
	PlanName: Upgrade_0_1_22_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
		}
	},
}

Upgrade_0_1_22 handles the upgrade to release `v0_1_22`. This upgrade adds: - Updates to the Morse account recovery allowlist

var Upgrade_0_1_23 = Upgrade{
	PlanName: Upgrade_0_1_23_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
		}
	},
}

Upgrade_0_1_23 handles the upgrade to release `v0.1.23`. This upgrade includes: - RelayMiner improvements (replaced EventsQueryClient with CometBFT client) - Tokenomics enhancements (non-chain halting claim settlement) - Service parameter updates and governance parameter adjustments

var Upgrade_0_1_24 = Upgrade{
	PlanName: Upgrade_0_1_24_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
		}
	},
}

Upgrade_0_1_24 handles the upgrade to release `v0.1.24`. This upgrade includes: - Supplier query enhancements (dehydrated flag for list-suppliers) - Supplier downstaking fixes (funds go to owner address) - Session parameter updates (numSuppliersPerSession increased to 50) - CLI improvements (count flag for relay command) - Telegram bot exchange list updates

var Upgrade_0_1_25 = Upgrade{
	PlanName: Upgrade_0_1_25_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
		}
	},
}

Upgrade_0_1_25 handles the upgrade to release `v0.1.25`. This upgrade adds: - Reduced SMST / onchain proof size by persisting payload-dehydrated relay responses - Reduced event related state bloat by removing unnecessary settlement results from events - Updated Morse account recovery allowlist

var Upgrade_0_1_26 = Upgrade{
	PlanName: Upgrade_0_1_26_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
		}
	},
}

Upgrade_0_1_26 handles the upgrade to release `v0.1.26`. This upgrade adds: - Implement backward compatible relay response signature verification to enable smooth protocol upgrades

var Upgrade_0_1_27 = Upgrade{
	PlanName: Upgrade_0_1_27_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

	CreateUpgradeHandler: func(
		mm *module.Manager,
		keepers *keepers.Keepers,
		configurator module.Configurator,
	) upgradetypes.UpgradeHandler {
		setIBCParams := func(ctx context.Context) (err error) {
			sdkCtx := cosmostypes.UnwrapSDKContext(ctx)
			logger := sdkCtx.Logger().With("upgrade_plan_name", Upgrade_0_1_27_PlanName)
			logger.Info("Starting IBC parameter configuration")

			estimatedBlockDuration, isFound := pocket.EstimatedBlockDurationByChainId[sdkCtx.ChainID()]
			if !isFound {
				return fmt.Errorf("chain ID %s not found in EstimatedBlockDurationByChainId", sdkCtx.ChainID())
			}

			maxExpectedBlockTimeSeconds := estimatedBlockDuration.Seconds() * BlockTimeAdjustmentFactor
			ibcConnectionParamMaxExpectedTimePerBlock, err := time.ParseDuration(
				fmt.Sprintf(durationSecondsFormat, maxExpectedBlockTimeSeconds),
			)
			if err != nil {
				return err
			}

			ibcConnectionParams := connectiontypes.Params{
				MaxExpectedTimePerBlock: uint64(ibcConnectionParamMaxExpectedTimePerBlock.Nanoseconds()),
			}
			logger.Info("Setting IBC connection params", "params", ibcConnectionParams)

			upgradeTimeoutSeconds := estimatedBlockDuration.Seconds() * 4 * BlockTimeAdjustmentFactor

			ibcChannelParamUpgradeTimeoutTimestamp, err := time.ParseDuration(
				fmt.Sprintf(durationSecondsFormat, upgradeTimeoutSeconds),
			)
			if err != nil {
				return err
			}

			ibcChannelParams := channeltypes.Params{
				UpgradeTimeout: channeltypes.Timeout{
					Height: ibcclienttypes.Height{
						RevisionNumber: IbcChannelParamUpgradeTimeoutRevisionNumber,
						RevisionHeight: IbcChannelParamUpgradeTimeoutRevisionHeight,
					},
					Timestamp: uint64(ibcChannelParamUpgradeTimeoutTimestamp.Nanoseconds()),
				},
			}
			logger.Info("Setting IBC channel params", "params", ibcChannelParams)

			ibcClientParams := ibcclienttypes.Params{
				AllowedClients: IbcClientParamAllowedClients,
			}
			logger.Info("Setting IBC client params", "params", ibcClientParams)

			ibcTransferParams := ibctransfertypes.Params{
				SendEnabled:    IbcTransferParamSendEnabled,
				ReceiveEnabled: IbcTransferParamReceiveEnabled,
			}
			logger.Info("Setting IBC transfer params", "params", ibcTransferParams)

			ibcIcaHostParams := icahosttypes.Params{
				HostEnabled:   IbcIcaHostParamHostEnabled,
				AllowMessages: IbcIcaHostParamAllowMessages,
			}
			logger.Info("Setting IBC interchain accounts host params", "params", ibcIcaHostParams)

			ibcIcaControllerParams := icacontrollertypes.Params{
				ControllerEnabled: IbcIcaControllerParamControllerEnabled,
			}
			logger.Info("Setting IBC interchain accounts controller params", "params", ibcIcaControllerParams)

			keepers.IBCKeeper.ConnectionKeeper.SetParams(sdkCtx, ibcConnectionParams)
			keepers.IBCKeeper.ChannelKeeper.SetParams(sdkCtx, ibcChannelParams)
			keepers.IBCKeeper.ClientKeeper.SetParams(sdkCtx, ibcClientParams)

			keepers.TransferKeeper.SetParams(sdkCtx, ibcTransferParams)

			keepers.ICAHostKeeper.SetParams(sdkCtx, ibcIcaHostParams)
			keepers.ICAControllerKeeper.SetParams(sdkCtx, ibcIcaControllerParams)

			keepers.IBCKeeper.ClientKeeper.SetNextClientSequence(sdkCtx, 0)

			keepers.IBCKeeper.ConnectionKeeper.SetNextConnectionSequence(sdkCtx, 0)

			keepers.IBCKeeper.ChannelKeeper.SetNextChannelSequence(sdkCtx, 0)

			transferGenesis := ibctransfertypes.GenesisState{
				PortId:      ibctransfertypes.PortID,
				DenomTraces: []ibctransfertypes.DenomTrace{},
				Params: ibctransfertypes.Params{
					SendEnabled:    IbcTransferParamSendEnabled,
					ReceiveEnabled: IbcTransferParamReceiveEnabled,
				},
				TotalEscrowed: cosmostypes.NewCoins(),
			}

			keepers.TransferKeeper.InitGenesis(sdkCtx, transferGenesis)
			logger.Info("Successfully completed IBC parameter configuration")

			return nil
		}

		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_27_PlanName)
			logger.Info("Starting upgrade handler")

			tokenomicsParams := keepers.TokenomicsKeeper.GetParams(ctx)
			tokenomicsParams.MintEqualsBurnClaimDistribution = tokenomicstypes.DefaultMintEqualsBurnClaimDistribution
			if err := keepers.TokenomicsKeeper.SetParams(ctx, tokenomicsParams); err != nil {
				return nil, err
			}

			if err := setIBCParams(ctx); err != nil {
				logger.Error("Failed to set IBC parameters", "error", err)
				return vm, err
			}

			logger.Info("Successfully completed upgrade handler")

			return vm, nil
		}
	},
}

Upgrade_0_1_27 handles the upgrade to release `v0.1.27`. This upgrade adds/changes: - Updates to the Morse account recovery allowlist - Distributed Settlement TLM: enable_distribute_settlement parameter - Reward distribution for the mint=burn TLM - Updates to the Morse account recovery allowlist - Sets all IBC parameters to enable IBC support

var Upgrade_0_1_28 = Upgrade{
	PlanName: Upgrade_0_1_28_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
		}
	},
}

Upgrade_0_1_28 handles the upgrade to release `v0.1.28`. This upgrade adds/changes (diff: v0.1.27..v0.1.28 / current main): - Shared module param update: increased `ComputeUnitsPerRelayMax`. - Tokenomics updates: validator proper decoding fix; updated DAO address in mint_equals_burn_claim_distribution; - Recovery: updated Morse account recovery allowlist (multiple iterations, incl. 8 Aug 2025 update).

var Upgrade_0_1_29 = Upgrade{
	PlanName: Upgrade_0_1_29_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
		}
	},
}

Upgrade_0_1_29 handles the upgrade to release `v0.1.29`. This upgrade adds: - update Morse account recovery allowlist - tokenomics update: "proposer" reward distributed to all validators/delegators - supplier stake message handling & authorization

var Upgrade_0_1_3 = Upgrade{
	PlanName: Upgrade_0_1_3_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_1_3 handles the upgrade to release `v0.1.3`. This is planned to be issued on both Pocket Network's Shannon Alpha & Beta TestNets. It is a small upgrade intended to reduce the memory footprint of session suppliers. Key change: - https://github.com/pokt-network/poktroll/pull/1214 https://github.com/pokt-network/poktroll/compare/v0.1.2..b2d023a

var Upgrade_0_1_30 = Upgrade{
	PlanName: Upgrade_0_1_30_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
		}
	},
}

Upgrade_0_1_30 handles the upgrade to release `v0.1.30`. This upgrade includes: - Supplier service config update logic before activation fix - Experimental onchain metadata support - RelayMiner performance improvements (signatures, caching, etc) - New recovery wallets and docs See: https://github.com/pokt-network/poktroll/pull/1847

var Upgrade_0_1_31 = Upgrade{
	PlanName: Upgrade_0_1_31_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 PIP-41 parameter updates", "upgrade_plan_name", Upgrade_0_1_31_PlanName)

			tokenomicsParams := keepers.TokenomicsKeeper.GetParams(ctx)

			if tokenomicsParams.MintRatio == 0 {
				tokenomicsParams.MintRatio = tokenomicstypes.DefaultMintRatio
				logger.Info("PIP-41: Setting default mint_ratio to 1.0 (governance can activate deflation)")
			}

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

			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 with PIP-41 mint_ratio", "new_params", tokenomicsParams)

			return nil
		}

		initializeParamsHistory := func(ctx context.Context, logger cosmoslog.Logger, upgradeHeight int64) error {
			logger.Info("Initializing historical params tracking", "upgrade_plan_name", Upgrade_0_1_31_PlanName)

			sharedParams := keepers.SharedKeeper.GetParams(ctx)
			if err := keepers.SharedKeeper.SetParamsAtHeight(ctx, upgradeHeight, sharedParams); err != nil {
				logger.Error("Failed to initialize shared params history", "error", err)
				return err
			}
			logger.Info("Initialized shared params history",
				"effective_height", upgradeHeight,
				"num_blocks_per_session", sharedParams.NumBlocksPerSession,
			)

			sessionParams := keepers.SessionKeeper.GetParams(ctx)
			if err := keepers.SessionKeeper.SetParamsAtHeight(ctx, upgradeHeight, sessionParams); err != nil {
				logger.Error("Failed to initialize session params history", "error", err)
				return err
			}
			logger.Info("Initialized session params history",
				"effective_height", upgradeHeight,
				"num_suppliers_per_session", sessionParams.NumSuppliersPerSession,
			)

			return nil
		}

		initializeDifficultyHistory := func(ctx context.Context, logger cosmoslog.Logger, upgradeHeight int64) error {
			logger.Info("Initializing relay mining difficulty history", "upgrade_plan_name", Upgrade_0_1_31_PlanName)

			allDifficulties := keepers.ServiceKeeper.GetAllRelayMiningDifficulty(ctx)

			for _, difficulty := range allDifficulties {
				serviceId := difficulty.ServiceId

				existingHistory := keepers.ServiceKeeper.GetRelayMiningDifficultyHistoryForService(ctx, serviceId)

				if len(existingHistory) > 0 {
					logger.Info("Found existing difficulty history, will ensure entry exists at upgrade height",
						"service_id", serviceId,
						"num_existing_entries", len(existingHistory),
					)
				}

				if err := keepers.ServiceKeeper.SetRelayMiningDifficultyAtHeight(ctx, upgradeHeight, difficulty); err != nil {
					logger.Error("Failed to initialize difficulty history",
						"service_id", serviceId,
						"error", err,
					)
					return err
				}
				logger.Info("Initialized difficulty history at upgrade height",
					"service_id", serviceId,
					"effective_height", upgradeHeight,
					"target_hash", difficulty.TargetHash,
				)
			}

			return nil
		}

		cleanupOrphanedServiceConfigIndexes := func(ctx context.Context, logger cosmoslog.Logger) error {
			logger.Info("Cleaning up orphaned service config indexes")

			actCount, deactCount, supplierCount, err := keepers.SupplierKeeper.CleanupOrphanedServiceConfigIndexes(ctx)
			if err != nil {
				logger.Error("Failed to cleanup orphaned indexes", "error", err)
				return err
			}

			logger.Info("Cleaned up orphaned service config indexes",
				"activation_cleaned", actCount,
				"deactivation_cleaned", deactCount,
				"supplier_cleaned", supplierCount,
			)
			return nil
		}

		grantPnfAuthzPermissions := func(ctx context.Context, logger cosmoslog.Logger) error {
			sdkCtx := cosmostypes.UnwrapSDKContext(ctx)
			chainID := sdkCtx.ChainID()

			if chainID != "pocket" {
				logger.Info("Skipping PNF authz grants (not mainnet - betanet PNF already has full permissions)", "chain_id", chainID)
				return nil
			}

			logger.Info("Granting missing authz permissions to MainNet PNF", "upgrade_plan_name", Upgrade_0_1_31_PlanName)

			pnfAddress := MainNetPnfAddress
			logger.Info("Granting to MainNet PNF", "address", pnfAddress)

			missingAuthzMessages := []string{

				"/cosmos.authz.v1beta1.MsgExec",
				"/cosmos.authz.v1beta1.MsgGrant",
				"/cosmos.authz.v1beta1.MsgRevoke",
				"/cosmos.authz.v1beta1.MsgRevokeAll",
				"/cosmos.authz.v1beta1.MsgPruneExpiredGrants",

				"/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade",
				"/cosmos.upgrade.v1beta1.MsgCancelUpgrade",

				"/cosmos.gov.v1.MsgCancelProposal",

				"/pocket.migration.MsgImportMorseClaimableAccounts",
				"/pocket.migration.MsgRecoverMorseAccount",
				"/pocket.migration.MsgAdminRecoverMorseAccount",
				"/pocket.service.MsgRecoverMorseAccount",
			}

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

			granterAddr := keepers.MigrationKeeper.GetAuthority()
			granterCosmosAddr := cosmostypes.MustAccAddressFromBech32(granterAddr)
			pnfCosmosAddr := cosmostypes.MustAccAddressFromBech32(pnfAddress)

			for _, msg := range missingAuthzMessages {
				err = keepers.AuthzKeeper.SaveGrant(
					ctx,
					pnfCosmosAddr,
					granterCosmosAddr,
					authz.NewGenericAuthorization(msg),
					&expiration,
				)
				if err != nil {
					return fmt.Errorf("failed to save grant for message %s: %w", msg, err)
				}
				logger.Info("Granted authorization", "msg", msg, "to", pnfAddress)
			}

			logger.Info("Successfully granted missing authz permissions to PNF", "total_grants", len(missingAuthzMessages))
			return nil
		}

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

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

			if err := initializeParamsHistory(ctx, logger, sdkCtx.BlockHeight()); err != nil {
				return vm, err
			}

			if err := initializeDifficultyHistory(ctx, logger, sdkCtx.BlockHeight()); err != nil {
				return vm, err
			}

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

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

			return vm, nil
		}
	},
}

Upgrade_0_1_31 handles the upgrade to release `v0.1.31`. This upgrade implements:

1. PIP-41: Deflationary Mint Mechanism

• Adds new `mint_ratio` parameter to tokenomics module
• Default value is 1.0 (no deflation - backward compatible)
• Governance can later set to 0.975 to enable 2.5% deflation
• See: https://forum.pokt.network/t/pip-41-introducing-a-deflationary-mint-mechanism-for-shannon-tokenomics/5622

2. Historical Parameter Tracking

• Initializes param history for shared and session modules at upgrade height
• Ensures session boundary calculations remain correct after param changes
• Fixes claim/proof validation failures when params change mid-session
• See: https://github.com/pokt-network/poktroll/issues/543

3. PNF Authz Grants (Mainnet Only)

• Grants 12 missing authz permissions to PNF on mainnet
• Enables PNF to manage authorizations, upgrades, governance, and admin recovery
• Prepares for transition from Grove to PNF as primary authority
• Includes new MsgAdminRecoverMorseAccount for fast recovery without allowlist
• Note: Betanet PNF already has all permissions, no action needed

var Upgrade_0_1_31_Beta_2 = Upgrade{
	PlanName: Upgrade_0_1_31_Beta_2_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 PIP-41 parameter updates", "upgrade_plan_name", Upgrade_0_1_31_Beta_2_PlanName)

			tokenomicsParams := keepers.TokenomicsKeeper.GetParams(ctx)

			if tokenomicsParams.MintRatio == 0 {
				tokenomicsParams.MintRatio = tokenomicstypes.DefaultMintRatio
				logger.Info("PIP-41: Setting default mint_ratio to 1.0")
			}

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

			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 with PIP-41 mint_ratio", "new_params", tokenomicsParams)

			return nil
		}

		initializeParamsHistory := func(ctx context.Context, logger cosmoslog.Logger, upgradeHeight int64) error {
			logger.Info("Initializing historical params tracking", "upgrade_plan_name", Upgrade_0_1_31_Beta_2_PlanName)

			sharedParams := keepers.SharedKeeper.GetParams(ctx)
			if err := keepers.SharedKeeper.SetParamsAtHeight(ctx, upgradeHeight, sharedParams); err != nil {
				logger.Error("Failed to initialize shared params history", "error", err)
				return err
			}
			logger.Info("Initialized shared params history",
				"effective_height", upgradeHeight,
				"num_blocks_per_session", sharedParams.NumBlocksPerSession,
			)

			sessionParams := keepers.SessionKeeper.GetParams(ctx)
			if err := keepers.SessionKeeper.SetParamsAtHeight(ctx, upgradeHeight, sessionParams); err != nil {
				logger.Error("Failed to initialize session params history", "error", err)
				return err
			}
			logger.Info("Initialized session params history",
				"effective_height", upgradeHeight,
				"num_suppliers_per_session", sessionParams.NumSuppliersPerSession,
			)

			return nil
		}

		initializeDifficultyHistory := func(ctx context.Context, logger cosmoslog.Logger, upgradeHeight int64) error {
			logger.Info("Initializing relay mining difficulty history", "upgrade_plan_name", Upgrade_0_1_31_Beta_2_PlanName)

			allDifficulties := keepers.ServiceKeeper.GetAllRelayMiningDifficulty(ctx)

			for _, difficulty := range allDifficulties {
				serviceId := difficulty.ServiceId

				existingHistory := keepers.ServiceKeeper.GetRelayMiningDifficultyHistoryForService(ctx, serviceId)

				if len(existingHistory) > 0 {
					logger.Info("Found existing difficulty history, will ensure entry exists at upgrade height",
						"service_id", serviceId,
						"num_existing_entries", len(existingHistory),
					)
				}

				if err := keepers.ServiceKeeper.SetRelayMiningDifficultyAtHeight(ctx, upgradeHeight, difficulty); err != nil {
					logger.Error("Failed to initialize difficulty history",
						"service_id", serviceId,
						"error", err,
					)
					return err
				}
				logger.Info("Initialized difficulty history at upgrade height",
					"service_id", serviceId,
					"effective_height", upgradeHeight,
					"target_hash", difficulty.TargetHash,
				)
			}

			return nil
		}

		cleanupOrphanedServiceConfigIndexes := func(ctx context.Context, logger cosmoslog.Logger) error {
			logger.Info("Cleaning up orphaned service config indexes")

			actCount, deactCount, supplierCount, err := keepers.SupplierKeeper.CleanupOrphanedServiceConfigIndexes(ctx)
			if err != nil {
				logger.Error("Failed to cleanup orphaned indexes", "error", err)
				return err
			}

			logger.Info("Cleaned up orphaned service config indexes",
				"activation_cleaned", actCount,
				"deactivation_cleaned", deactCount,
				"supplier_cleaned", supplierCount,
			)
			return nil
		}

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

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

			if err := initializeParamsHistory(ctx, logger, sdkCtx.BlockHeight()); err != nil {
				return vm, err
			}

			if err := initializeDifficultyHistory(ctx, logger, sdkCtx.BlockHeight()); err != nil {
				return vm, err
			}

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

			logger.Info("Successfully completed v0.1.31-beta-2 upgrade for betanet")
			return vm, nil
		}
	},
}

Upgrade_0_1_31_Beta_2 handles the betanet upgrade to test v0.1.31 fixes. This upgrade implements the same changes as v0.1.31 plus critical bug fixes:

1. PIP-41: Deflationary Mint Mechanism

• Adds new `mint_ratio` parameter to tokenomics module
• Default value is 1.0 (no deflation - backward compatible)

2. Historical Parameter Tracking

• Initializes param history for shared and session modules at upgrade height
• Ensures session boundary calculations remain correct after param changes

3. Orphaned Service Config Index Cleanup (NEW - Bug Fix)

• Cleans up orphaned index entries from activation/deactivation/supplier indexes
• Fixes root cause: re-indexing now properly removes old entries before adding new ones
• See: x/supplier/keeper/supplier_index.go

4. Defensive Logging Improvements

• Changed orphaned entry warnings to debug level to reduce log noise

Note: This upgrade is for betanet only. Mainnet will use v0.1.31 or v0.1.32 depending on betanet test results.

var Upgrade_0_1_33 = Upgrade{
	PlanName: Upgrade_0_1_33_PlanName,

	StoreUpgrades: storetypes.StoreUpgrades{},

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

		cleanupOrphanedUndelegationIndexes := func(ctx context.Context, logger cosmoslog.Logger) error {
			logger.Info("Cleaning up orphaned application undelegation indexes")

			count, err := keepers.ApplicationKeeper.CleanupOrphanedUndelegationIndexes(ctx)
			if err != nil {
				logger.Error("Failed to cleanup orphaned undelegation indexes", "error", err)
				return err
			}

			logger.Info("Cleaned up orphaned application undelegation indexes",
				"orphaned_entries_removed", count,
			)
			return nil
		}

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

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

			return vm, nil
		}
	},
}

Upgrade_0_1_33 handles the upgrade to release `v0.1.33`. This upgrade fixes:

• removeApplicationUndelegationIndex deleting from the wrong store (delegation store instead of undelegation store), causing orphaned undelegation index entries when applications with pending undelegations were removed (unstaked/transferred). Bug introduced in PR #1263 (v0.1.31). The upgrade handler cleans up any orphaned entries accumulated since v0.1.31.

P0 audit fixes (from v0.1.31 audit):

• getSupplierServiceConfigUpdates now skips orphaned index entries (nil primary record) instead of calling MustUnmarshal(nil) which produces zero-value structs with Service == nil. Mirrors the existing nil check in removeSupplierServiceConfigUpdateIndexes.
• shared module's MsgUpdateParams (bulk/governance) now calls recordParamsHistory before SetParams, matching the singular MsgUpdateParam and session module's MsgUpdateParams. Without this, governance bulk param updates bypassed history recording, causing GetParamsAtHeight to return stale values.

P1 audit fixes (from v0.1.31 audit):

• SubmitProof: Added error checks after GetClaimeduPOKT and GetNumEstimatedComputeUnits calls. Previously the second := assignment silently overwrote the error from the first, causing incorrect zero-value data in events when GetClaimeduPOKT failed.
• proof/claim handlers (CreateClaim, SubmitProof, ProofRequirementForClaim): Replaced sharedKeeper.GetParams(ctx) with GetParamsAtHeight(ctx, sessionStartHeight) so that claimed uPOKT and proof requirement calculations use the shared params that were effective when the session started, not the current params.
• SharedKeeperQueryClient (GetEarliestSupplierClaimCommitHeight, GetEarliestSupplierProofCommitHeight): Replaced sharedKeeper.GetParams(ctx) with GetParamsAtHeight(ctx, queryHeight) so that claim/proof window calculations use historical params consistent with the session-level window validation in session.go.

P2 audit fixes (from v0.1.31 audit):

• session_hydrator: Fixed potential integer overflow in supplier sort comparison. generateSupplierRandomWeight produces values across the full int64 range; subtraction (weightA - weightB) could overflow, violating sort's trichotomy property. Replaced with explicit comparison (<, >, ==).

P3 audit fixes (from v0.1.31 audit):

• tokenomics: Zero-mint guard in processTokenomicsMint — returns error when settlementAmount * mint_ratio truncates to 0, preventing silent claim loss.
• tokenomics: ValidateMintRatio now rejects 0 (range (0, 1] strictly enforced), removed stale auto-correction in ValidateBasic.
• shared/session keepers: Added HasParamsHistory() O(1) check, replacing O(n) GetAllParamsHistory() emptiness check in recordParamsHistory/RecordParamsHistory.
• shared/session genesis: Export/import params_history in ExportGenesis/InitGenesis, ensuring param history survives chain export/import cycles.
• application CLI: New stake-and-delegate command sends MsgStakeApplication + N × MsgDelegateToGateway in a single transaction via extended config YAML.
• application: CONSENSUS-BREAKING — Fixed IsActive() OR-chain logic that always returned true. Unbonding/transferring apps past their end height are now correctly excluded from sessions.

Settlement event improvements (event-only, no state changes):

• EventClaimSettled: Added `settled_upokt` (post-cap, pre-mint_ratio amount) and `mint_ratio` fields so indexers can decompose overservicing loss vs deflation loss.
• EventApplicationOverserviced: BREAKING SEMANTIC CHANGE — `effective_burn` now includes the globalInflation component, matching `expected_burn`'s basis. Previously `effective_burn` excluded globalInflation, making the gap (expected_burn - effective_burn) appear larger than actual overservicing. Indexers (e.g. pocketdex) that compute overservicing amounts from this gap will see smaller, more accurate values after this upgrade.
• EventApplicationOverserviced: Added `service_id` and `session_end_block_height` fields to enable unambiguous joins with EventClaimSettled. Previously indexers had to match on (app_addr, supplier_addr) within the same block, which is ambiguous when the same pair has claims from multiple sessions settling together.

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
		}
	},
}

Upgrade_0_1_4 handles the upgrade to release `v0.1.4`. A follow up to `v0.1.2` that has to be re-applied due to the issues outlined here: https://github.com/cosmos/cosmos-sdk/pull/24548

var Upgrade_0_1_5 = Upgrade{
	PlanName: Upgrade_0_1_5_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_1_5 handles the upgrade to release `v0.1.5`. This is planned to be issued on both Pocket Network's Shannon Alpha, Beta TestNets as well as MainNet. It is an upgrade intended to reduce the memory footprint when iterating over Suppliers and Applications. https://github.com/pokt-network/poktroll/compare/v0.1.4..b92aa0c

var Upgrade_0_1_6 = Upgrade{
	PlanName: Upgrade_0_1_6_PlanName,

	CreateUpgradeHandler: defaultUpgradeHandler,

	StoreUpgrades: storetypes.StoreUpgrades{},
}

Upgrade_0_1_6 handles the upgrade to release `v0.1.6`. This is planned to be issued on both Pocket Network's Shannon Alpha, Beta TestNets as well as MainNet. It is an upgrade intended to reduce the memory by avoiding unnecessary marshaling of the supplier object when iterating over the suppliers. https://github.com/pokt-network/poktroll/compare/v0.1.5..c7ab386

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
		}
	},
}

Upgrade_0_1_7 handles the upgrade to release `v0.1.7`. This is planned to be issued on both Pocket Network's Shannon Alpha, Beta TestNets as well as MainNet. It is an upgrade intended to reduce the memory footprint when iterating over Suppliers and Applications. https://github.com/pokt-network/poktroll/compare/v0.1.6..99c393

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
		}
	},
}

Upgrade_0_1_8 handles the upgrade to release `v0.1.8`. This is planned to be issued on both Pocket Network's Shannon Alpha, Beta TestNets It is an upgrade intended to enable: - Suppliers service config indexing and more granular hydration. - Application indexing TODO_FOLLOWUP(#1230, @red-0ne): Update the github link from main to v0.1.8 once the upgrade is released. https://github.com/pokt-network/poktroll/compare/v0.1.7..v0.1.8

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
		}
	},
}

Upgrade_0_1_9 handles the upgrade to release `v0.1.9`. This is planned to be issued on both Pocket Network's Shannon Alpha, Beta TestNets as well as MainNet. It is an upgrade intended to reduce the claim settlement processing time by caching the redundant data in the store and avoiding unnecessary marshaling, indexing and data retrieval. https://github.com/pokt-network/poktroll/compare/v0.1.8..v0.1.9

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
		}
	},
}

Upgrade_NEXT handles the upgrade to release `vNEXT`. This upgrade adds: - Fix for supplier service config update logic before activation (issue #1794)

var Upgrade_NEXTTemplate = Upgrade{
	PlanName: Upgrade_NEXTTemplate_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
		}
	},
}

Upgrade_NEXTTemplate handles the upgrade to release `vNEXT`. This upgrade adds: - ...

Types

type Upgrade

type Upgrade struct {
	// PlanName is a name an upgrade is matched to from the onchain `upgradetypes.Plan`.
	PlanName string

	// CreateUpgradeHandler returns an upgrade handler that will be executed at the time of the upgrade.
	// State changes and protocol version upgrades should be performed here.
	CreateUpgradeHandler func(*module.Manager, *keepers.Keepers, module.Configurator) upgradetypes.UpgradeHandler

	// StoreUpgrades adds, renames and deletes KVStores in the state to prepare for a protocol upgrade.
	StoreUpgrades storetypes.StoreUpgrades
}

Upgrade represents a protocol upgrade in code. Once a `MsgSoftwareUpgrade` is submitted onchain, and `Upgrade.PlanName` matches the `Plan.Name`, the upgrade will be scheduled for execution at the corresponding height.