prepare initiation-2 upgrade (#292)

* prepare upgrade initiation-2

* fetching code bytes with precompile readlib func

* delete existing upgrade handler

* dont delete if it is module

* add cosmos move

* add get&set checksums, genesis import&export module checksums

* change checksum func

* initialize staking at genesis (#290)

* movevm loaderv2 integration (#284)

* connect movevm with loaderv2 and introduce module & script cache

* use cache context before query

* disable unstable

* update movevm to latest

* add toml description

---------

Co-authored-by: beer-1 <[email protected]>

* wip

* delete keys after iteration

* clone key value

* fix

* reverse iterate vmstore & set keys

* final touch

* update swagger docs

---------

Co-authored-by: beer-1 <[email protected]>
Co-authored-by: beer-1 <[email protected]>

app/upgrade.go

@@ -1,45 +1,98 @@
 package app
 
 import (
+	"bytes"
 	"context"
-	"encoding/base64"
+	"errors"
+	"fmt"
 
-	"cosmossdk.io/errors"
+	"cosmossdk.io/collections"
+	sdkerrors "cosmossdk.io/errors"
 	upgradetypes "cosmossdk.io/x/upgrade/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 
 	movetypes "github.com/initia-labs/initia/x/move/types"
+	vmprecompile "github.com/initia-labs/movevm/precompile"
 	vmtypes "github.com/initia-labs/movevm/types"
 )
 
-const upgradeName = "0.5.6"
+const upgradeName = "0.6.0"
 
 // RegisterUpgradeHandlers returns upgrade handlers
 func (app *InitiaApp) RegisterUpgradeHandlers(cfg module.Configurator) {
 	app.UpgradeKeeper.SetUpgradeHandler(
 		upgradeName,
 		func(ctx context.Context, _ upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
-			// diff: https://github.com/initia-labs/movevm/compare/v0.4.12...v0.5.0
-			codes := []string{
-				// cosmos.move
-				"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",
-				// coin.move
-				"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",
+
+			// 1. publish new code module first
+			codeModuleBz, err := vmprecompile.ReadStdlib("code.mv")
+			if err != nil {
+				return nil, err
 			}
+			err = app.MoveKeeper.SetModule(ctx, vmtypes.StdAddress, movetypes.MoveModuleNameCode, codeModuleBz[0])
+			if err != nil {
+				return nil, err
+			}
+
+			// 2. update vm data with new seperator and add checksums of each module
+
+			//  Previous:
+			// 	ModuleSeparator     = byte(0)
+			// 	ResourceSeparator   = byte(1)
+			// 	TableEntrySeparator = byte(2)
+			//	TableInfoSeparator  = byte(3)
+
+			//  Current:
+			// 	ModuleSeparator     = byte(0)
+			//	ChecksumSeparator   = byte(1)
+			// 	ResourceSeparator   = byte(2)
+			// 	TableEntrySeparator = byte(3)
+			//	TableInfoSeparator  = byte(4)
+
+			err = app.MoveKeeper.VMStore.Walk(ctx, new(collections.Range[[]byte]).Descending(), func(key, value []byte) (stop bool, err error) {
+				key = bytes.Clone(key)
+
+				cursor := movetypes.AddressBytesLength
+				if len(key) <= cursor {
+					return true, fmt.Errorf("invalid key length: %d", len(key))
+				}
+
+				separator := key[cursor]
+				if separator == movetypes.ModuleSeparator {
+					checksum := movetypes.ModuleBzToChecksum(value)
+					value = checksum[:]
+				} else if separator >= movetypes.TableInfoSeparator {
+					return true, errors.New("unknown prefix")
+				} else if err = app.MoveKeeper.VMStore.Remove(ctx, key); err != nil {
+					return true, err
+				}
 
-			modules := make([]vmtypes.Module, len(codes))
-			for i, code := range codes {
-				codeBz, err := base64.StdEncoding.DecodeString(code)
+				key[cursor] = key[cursor] + 1
+				err = app.MoveKeeper.VMStore.Set(ctx, key, value)
 				if err != nil {
-					return nil, errors.Wrap(err, "failed to decode module code")
+					return true, err
 				}
 
+				return false, nil
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			// 3. update new modules
+
+			codesBz, err := vmprecompile.ReadStdlib("object_code_deployment.mv", "coin.mv", "cosmos.mv", "dex.mv", "json.mv", "bech32.mv", "hash.mv", "collection.mv")
+			if err != nil {
+				return nil, err
+			}
+			modules := make([]vmtypes.Module, len(codesBz))
+			for i, codeBz := range codesBz {
 				modules[i] = vmtypes.NewModule(codeBz)
 			}
 
-			err := app.MoveKeeper.PublishModuleBundle(ctx, vmtypes.StdAddress, vmtypes.NewModuleBundle(modules...), movetypes.UpgradePolicy_COMPATIBLE)
+			err = app.MoveKeeper.PublishModuleBundle(ctx, vmtypes.StdAddress, vmtypes.NewModuleBundle(modules...), movetypes.UpgradePolicy_COMPATIBLE)
 			if err != nil {
-				return nil, errors.Wrap(err, "failed to publish module bundle")
+				return nil, sdkerrors.Wrap(err, "failed to publish module bundle")
 			}
 
 			return vm, nil