refactor(upgrade): split migration logic into multiple files

app/upgrades/store/store.go

@@ -17,7 +17,7 @@ func RemoveStoreKeys(ctx sdk.Context, storeKey storetypes.StoreKey, prefixKeys [
 			deleteCount++
 		}
 		if deleteCount > 0 {
-			ctx.Logger().Info("remove store key", "kvStore", storeKey.Name(),
+			ctx.Logger().Info("remove store key", "kvStore", "module", "upgrade", storeKey.Name(),
 				"prefix", prefixKey[0], "deleteKeyCount", deleteCount)
 		}
 	}

app/upgrades/v8/bank.go

@@ -0,0 +1,56 @@
+package v8
+
+import (
+	"errors"
+
+	"cosmossdk.io/collections"
+	sdkmath "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+)
+
+func migrateBankModule(ctx sdk.Context, bankKeeper bankkeeper.Keeper) error {
+	sendEnabledEntry, found := bankKeeper.GetSendEnabledEntry(ctx, fxtypes.LegacyFXDenom)
+	if found {
+		bankKeeper.DeleteSendEnabled(ctx, fxtypes.LegacyFXDenom)
+		bankKeeper.SetSendEnabled(ctx, fxtypes.DefaultDenom, sendEnabledEntry.Enabled)
+	}
+
+	var err error
+	fxSupply := bankKeeper.GetSupply(ctx, fxtypes.LegacyFXDenom)
+	apundiaiSupply := sdkmath.ZeroInt()
+
+	bk, ok := bankKeeper.(bankkeeper.BaseKeeper)
+	if !ok {
+		return errors.New("bank keeper not implement bank.BaseKeeper")
+	}
+	bk.IterateAllBalances(ctx, func(address sdk.AccAddress, coin sdk.Coin) (stop bool) {
+		if coin.Denom != fxtypes.LegacyFXDenom {
+			return false
+		}
+		if err = bk.Balances.Remove(ctx, collections.Join(address, coin.Denom)); err != nil {
+			return true
+		}
+		coin.Denom = fxtypes.DefaultDenom
+		coin.Amount = fxtypes.SwapAmount(coin.Amount)
+		if !coin.IsPositive() {
+			return false
+		}
+		apundiaiSupply = apundiaiSupply.Add(coin.Amount)
+		if err = bk.Balances.Set(ctx, collections.Join(address, coin.Denom), coin.Amount); err != nil {
+			return true
+		}
+		return false
+	})
+	if err != nil {
+		return err
+	}
+
+	ctx.Logger().Info("migrate fx to apundiai", "module", "upgrade", "FX supply", fxSupply.Amount.String(), "apundiai supply", apundiaiSupply.String())
+	if err = bk.Supply.Remove(ctx, fxtypes.LegacyFXDenom); err != nil {
+		return err
+	}
+	return bk.Supply.Set(ctx, fxtypes.DefaultDenom, apundiaiSupply)
+}

app/upgrades/v8/bridge.go

@@ -0,0 +1,110 @@
+package v8
+
+import (
+	"strings"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+	bsctypes "github.com/pundiai/fx-core/v8/x/bsc/types"
+	crosschaintypes "github.com/pundiai/fx-core/v8/x/crosschain/types"
+	erc20keeper "github.com/pundiai/fx-core/v8/x/erc20/keeper"
+	erc20types "github.com/pundiai/fx-core/v8/x/erc20/types"
+)
+
+func migrateERC20TokenToCrosschain(ctx sdk.Context, bankKeeper bankkeeper.Keeper, erc20Keeper erc20keeper.Keeper) error {
+	balances := bankKeeper.GetAllBalances(ctx, authtypes.NewModuleAddress(erc20types.ModuleName))
+	migrateCoins := sdk.NewCoins()
+	for _, bal := range balances {
+		has, err := erc20Keeper.HasToken(ctx, bal.Denom)
+		if err != nil {
+			return err
+		}
+		if !has {
+			continue
+		}
+		migrateCoins = migrateCoins.Add(bal)
+	}
+	ctx.Logger().Info("migrate erc20 bridge/ibc token to crosschain", "module", "upgrade", "coins", migrateCoins.String())
+	return bankKeeper.SendCoinsFromModuleToModule(ctx, erc20types.ModuleName, crosschaintypes.ModuleName, migrateCoins)
+}
+
+func mintPurseBridgeToken(ctx sdk.Context, erc20Keeper erc20keeper.Keeper, bankKeeper bankkeeper.Keeper) error {
+	pxEscrowPurse, err := getPundixEscrowPurseAmount(ctx)
+	if err != nil {
+		return err
+	}
+
+	ibcToken, err := erc20Keeper.GetIBCToken(ctx, "channel-0", "purse")
+	if err != nil {
+		return err
+	}
+	bscPurseToken, err := erc20Keeper.GetBridgeToken(ctx, bsctypes.ModuleName, "purse")
+	if err != nil {
+		return err
+	}
+	ibcTokenSupply := bankKeeper.GetSupply(ctx, ibcToken.GetIbcDenom())
+	bscPurseAmount := sdk.NewCoin(bscPurseToken.BridgeDenom(), pxEscrowPurse.Sub(ibcTokenSupply.Amount))
+	return bankKeeper.MintCoins(ctx, bsctypes.ModuleName, sdk.NewCoins(bscPurseAmount))
+}
+
+func migrateBridgeBalance(ctx sdk.Context, bankKeeper bankkeeper.Keeper, accountKeeper authkeeper.AccountKeeper) error {
+	mds := bankKeeper.GetAllDenomMetaData(ctx)
+	for _, md := range mds {
+		if md.Base == fxtypes.LegacyFXDenom || (len(md.DenomUnits) == 0 || len(md.DenomUnits[0].Aliases) == 0) && md.Symbol != pundixSymbol {
+			continue
+		}
+		dstBase := md.Base
+		if !strings.Contains(md.Base, strings.ToLower(md.Symbol)) {
+			dstBase = strings.ToLower(md.Symbol)
+		}
+		srcDenoms := make([]string, 0, len(md.DenomUnits[0].Aliases)+1)
+		if md.Base != dstBase {
+			// pundix, purse
+			srcDenoms = append(srcDenoms, md.Base)
+		}
+		srcDenoms = append(srcDenoms, md.DenomUnits[0].Aliases...)
+		if len(srcDenoms) == 0 {
+			continue
+		}
+
+		for _, srcDenom := range srcDenoms {
+			if err := migrateAccountBalance(ctx, bankKeeper, accountKeeper, srcDenom, dstBase); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func migrateAccountBalance(ctx sdk.Context, bankKeeper bankkeeper.Keeper, accountKeeper authkeeper.AccountKeeper, srcBase, dstBase string) error {
+	var err error
+	bankKeeper.IterateAllBalances(ctx, func(address sdk.AccAddress, coin sdk.Coin) (stop bool) {
+		if coin.Denom != srcBase {
+			return false
+		}
+
+		account := accountKeeper.GetAccount(ctx, address)
+		if _, ok := account.(sdk.ModuleAccountI); ok {
+			return false
+		}
+
+		ctx.Logger().Info("migrate coin", "module", "upgrade", "address", address.String(), "src-denom", srcBase, "dst-denom", dstBase, "amount", coin.Amount.String())
+		if err = bankKeeper.SendCoinsFromAccountToModule(ctx, address, erc20types.ModuleName, sdk.NewCoins(coin)); err != nil {
+			return true
+		}
+		coin.Denom = dstBase
+		if err = bankKeeper.MintCoins(ctx, crosschaintypes.ModuleName, sdk.NewCoins(coin)); err != nil {
+			return true
+		}
+		if err = bankKeeper.SendCoinsFromModuleToAccount(ctx, crosschaintypes.ModuleName, address, sdk.NewCoins(coin)); err != nil {
+			return true
+		}
+
+		return false
+	})
+	return err
+}

app/upgrades/v8/constants.go

@@ -61,10 +61,9 @@ func getContractOwner(ctx sdk.Context) common.Address {
 }
 
 const (
-	pundixBase   = "pundix"
-	purseBase    = "purse"
-	pundixSymbol = "PUNDIX"
-	purseSymbol  = "PURSE"
+	pundixBaseDenom = "pundix"
+	purseBaseDenom  = "purse"
+	pundixSymbol    = "PUNDIX"
 )
 
 func getTestnetTokenAmount(ctx sdk.Context) map[string]sdkmath.Int {
@@ -85,3 +84,15 @@ func MustParseIntFromString(s string) sdkmath.Int {
 	}
 	return res
 }
+
+func GetMigrateEscrowDenoms(chainID string) map[string]string {
+	result := make(map[string]string, 2)
+	result[fxtypes.LegacyFXDenom] = fxtypes.DefaultDenom
+
+	pundixDenom := fxtypes.MainnetPundixUnWrapDenom
+	if chainID == fxtypes.TestnetChainId {
+		pundixDenom = fxtypes.TestnetPundixUnWrapDenom
+	}
+	result[pundixDenom] = fxtypes.PundixWrapDenom
+	return result
+}

app/upgrades/v8/contract.go

@@ -0,0 +1,77 @@
+package v8
+
+import (
+	"errors"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	"github.com/ethereum/go-ethereum/common"
+	evmtypes "github.com/evmos/ethermint/x/evm/types"
+
+	"github.com/pundiai/fx-core/v8/contract"
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+	crosschainkeeper "github.com/pundiai/fx-core/v8/x/crosschain/keeper"
+	erc20keeper "github.com/pundiai/fx-core/v8/x/erc20/keeper"
+	fxevmkeeper "github.com/pundiai/fx-core/v8/x/evm/keeper"
+)
+
+func deployBridgeFeeContract(ctx sdk.Context, evmKeeper *fxevmkeeper.Keeper, erc20Keeper erc20keeper.Keeper, crosschainKeeper crosschainkeeper.Keeper, evmModuleAddress common.Address) error {
+	chains := fxtypes.GetSupportChains()
+	bridgeDenoms := make([]contract.BridgeDenoms, len(chains))
+	for index, chain := range chains {
+		denoms := make([]common.Hash, 0)
+		bridgeTokens, err := erc20Keeper.GetBridgeTokens(ctx, chain)
+		if err != nil {
+			return err
+		}
+		for _, token := range bridgeTokens {
+			denoms = append(denoms, contract.MustStrToByte32(token.GetDenom()))
+		}
+		bridgeDenoms[index] = contract.BridgeDenoms{
+			ChainName: contract.MustStrToByte32(chain),
+			Denoms:    denoms,
+		}
+	}
+
+	oracles := crosschainKeeper.GetAllOracles(ctx, true)
+	if oracles.Len() <= 0 {
+		return errors.New("no oracle found")
+	}
+	defaultOracleAddress := common.HexToAddress(oracles[0].ExternalAddress)
+	return contract.DeployBridgeFeeContract(ctx, evmKeeper, bridgeDenoms, evmModuleAddress, getContractOwner(ctx), defaultOracleAddress)
+}
+
+func redeployTestnetContract(ctx sdk.Context, accountKeeper authkeeper.AccountKeeper, evmKeeper *fxevmkeeper.Keeper, erc20Keeper erc20keeper.Keeper, ethKeeper crosschainkeeper.Keeper) error {
+	if err := evmKeeper.DeleteAccount(ctx, common.HexToAddress(contract.BridgeFeeAddress)); err != nil {
+		return err
+	}
+	if err := evmKeeper.DeleteAccount(ctx, common.HexToAddress(contract.BridgeFeeOracleAddress)); err != nil {
+		return err
+	}
+
+	acc := accountKeeper.GetModuleAddress(evmtypes.ModuleName)
+	moduleAddress := common.BytesToAddress(acc.Bytes())
+	return deployBridgeFeeContract(ctx, evmKeeper, erc20Keeper, ethKeeper, moduleAddress)
+}
+
+func updateWPUNDIAILogicCode(ctx sdk.Context, keeper *fxevmkeeper.Keeper) {
+	wpundiai := contract.GetWPUNDIAI()
+	if err := keeper.UpdateContractCode(ctx, wpundiai.Address, wpundiai.Code); err != nil {
+		ctx.Logger().Error("update WPUNDIAI contract", "module", "upgrade", "err", err.Error())
+	} else {
+		ctx.Logger().Info("update WPUNDIAI contract", "module", "upgrade", "codeHash", wpundiai.CodeHash())
+	}
+}
+
+func updateERC20LogicCode(ctx sdk.Context, keeper *fxevmkeeper.Keeper) {
+	erc20 := contract.GetERC20()
+	if err := keeper.UpdateContractCode(ctx, erc20.Address, erc20.Code); err != nil {
+		ctx.Logger().Error("update ERC20 contract", "module", "upgrade", "err", err.Error())
+	} else {
+		ctx.Logger().Info("update ERC20 contract", "module", "upgrade", "codeHash", erc20.CodeHash())
+	}
+}
+
+func deployAccessControlContract(ctx sdk.Context, evmKeeper *fxevmkeeper.Keeper, evmModuleAddress common.Address) error {
+	return contract.DeployAccessControlContract(ctx, evmKeeper, evmModuleAddress, getContractOwner(ctx))
+}

app/upgrades/v8/crisis.go

@@ -0,0 +1,19 @@
+package v8
+
+import (
+	sdkmath "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	crisiskeeper "github.com/cosmos/cosmos-sdk/x/crisis/keeper"
+
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+)
+
+func migrateCrisisModule(ctx sdk.Context, crisisKeeper *crisiskeeper.Keeper) error {
+	constantFee, err := crisisKeeper.ConstantFee.Get(ctx)
+	if err != nil {
+		return err
+	}
+	constantFee.Denom = fxtypes.DefaultDenom
+	constantFee.Amount = sdkmath.NewInt(133).MulRaw(1e18)
+	return crisisKeeper.ConstantFee.Set(ctx, constantFee)
+}

app/upgrades/v8/crosschain.go

@@ -0,0 +1,56 @@
+package v8
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+
+	"github.com/pundiai/fx-core/v8/app/keepers"
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+	crosschaintypes "github.com/pundiai/fx-core/v8/x/crosschain/types"
+)
+
+func migrateCrosschainParams(ctx sdk.Context, keepers keepers.CrosschainKeepers) error {
+	for _, k := range keepers.ToSlice() {
+		params := k.GetParams(ctx)
+		params.DelegateThreshold.Denom = fxtypes.DefaultDenom
+		params.DelegateThreshold.Amount = fxtypes.SwapAmount(params.DelegateThreshold.Amount)
+		if !params.DelegateThreshold.IsPositive() {
+			return sdkerrors.ErrInvalidCoins.Wrapf("module %s invalid delegate threshold: %s",
+				k.ModuleName(), params.DelegateThreshold.String())
+		}
+		if err := k.SetParams(ctx, &params); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func migrateCrosschainModuleAccount(ctx sdk.Context, ak authkeeper.AccountKeeper) error {
+	addr, perms := ak.GetModuleAddressAndPermissions(crosschaintypes.ModuleName)
+	if addr == nil {
+		return sdkerrors.ErrInvalidAddress.Wrapf("crosschain module empty permissions")
+	}
+	acc := ak.GetAccount(ctx, addr)
+	if acc == nil {
+		return sdkerrors.ErrInvalidAddress.Wrapf("crosschain account not exist")
+	}
+	baseAcc, ok := acc.(*authtypes.BaseAccount)
+	if !ok {
+		return sdkerrors.ErrInvalidAddress.Wrapf("crosschain account not base account")
+	}
+	macc := authtypes.NewModuleAccount(baseAcc, crosschaintypes.ModuleName, perms...)
+	ak.SetModuleAccount(ctx, macc)
+	return nil
+}
+
+func migrateOracleDelegateAmount(ctx sdk.Context, keepers keepers.CrosschainKeepers) {
+	for _, k := range keepers.ToSlice() {
+		k.IterateOracle(ctx, func(oracle crosschaintypes.Oracle) bool {
+			oracle.DelegateAmount = fxtypes.SwapAmount(oracle.DelegateAmount)
+			k.SetOracle(ctx, oracle)
+			return false
+		})
+	}
+}

app/upgrades/v8/erc20.go

@@ -0,0 +1,20 @@
+package v8
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+	erc20keeper "github.com/pundiai/fx-core/v8/x/erc20/keeper"
+)
+
+func migrateErc20FXToPundiAI(ctx sdk.Context, keeper erc20keeper.Keeper) error {
+	erc20Token, err := keeper.GetERC20Token(ctx, fxtypes.LegacyFXDenom)
+	if err != nil {
+		return err
+	}
+	erc20Token.Denom = fxtypes.DefaultDenom
+	if err = keeper.ERC20Token.Set(ctx, erc20Token.Denom, erc20Token); err != nil {
+		return err
+	}
+	return keeper.ERC20Token.Remove(ctx, fxtypes.LegacyFXDenom)
+}

app/upgrades/v8/evm.go

@@ -0,0 +1,16 @@
+package v8
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	evmtypes "github.com/evmos/ethermint/x/evm/types"
+
+	fxtypes "github.com/pundiai/fx-core/v8/types"
+	fxevmkeeper "github.com/pundiai/fx-core/v8/x/evm/keeper"
+)
+
+func migrateEvmParams(ctx sdk.Context, evmKeeper *fxevmkeeper.Keeper) error {
+	params := evmKeeper.GetParams(ctx)
+	params.EvmDenom = fxtypes.DefaultDenom
+	params.HeaderHashNum = evmtypes.DefaultHeaderHashNum
+	return evmKeeper.SetParams(ctx, params)
+}