upgrades

Documentation

Index

• Constants
• Variables
• type Upgrade

Constants

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

	// TECHDEBT: DO NOT use AlphaTestNetAuthorityAddress.
	// This is the authority address used to create new authz authorizations. Defaults to x/gov module account address.
	// Use `keepers.UpgradeKeeper.Authority(ctx, &upgradetypes.QueryAuthorityRequest{})` to query the authority address of the current Alpha Network.
	// NOTE: This hard-coded address is kept for record-keeping historical purposes.
	AlphaTestNetAuthorityAddress = "pokt10d07y265gmmuvt4z0w9aw880jnsr700j8yv32t"

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

const Upgrade_0_0_12_PlanName = "v0.0.12"

Variables

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{
				"/poktroll.gateway.MsgUpdateParam",
				"/poktroll.application.MsgUpdateParam",
				"/poktroll.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.SetSupplier(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_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.

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.