[Morse->Shannon Migration] feat: implement Morse account state upload

cmd/poktrolld/cmd/migrate/migrate_test.go

@@ -1,23 +1,18 @@
 package migrate
 
 import (
-	"encoding/binary"
 	"fmt"
 	"math"
-	"math/rand"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
-	cometcrypto "github.com/cometbft/cometbft/crypto/ed25519"
 	cmtjson "github.com/cometbft/cometbft/libs/json"
-	cosmostypes "github.com/cosmos/cosmos-sdk/types"
-	"github.com/regen-network/gocuke"
 	"github.com/stretchr/testify/require"
 
-	"github.com/pokt-network/poktroll/app/volatile"
 	"github.com/pokt-network/poktroll/pkg/polylog/polyzero"
+	"github.com/pokt-network/poktroll/testutil/testmigration"
 	migrationtypes "github.com/pokt-network/poktroll/x/migration/types"
 )
 
@@ -32,7 +27,7 @@ func TestCollectMorseAccounts(t *testing.T) {
 	inputFile, err := os.CreateTemp(tmpDir, "morse-state-input.json")
 	require.NoError(t, err)
 
-	morseStateExportBz, morseAccountStateBz := newMorseStateExportAndAccountState(t, 10)
+	morseStateExportBz, morseAccountStateBz := testmigration.NewMorseStateExportAndAccountStateBytes(t, 10)
 	_, err = inputFile.Write(morseStateExportBz)
 	require.NoError(t, err)
 
@@ -61,7 +56,7 @@ func TestNewTestMorseStateExport(t *testing.T) {
 	for i := 1; i < 10; i++ {
 		t.Run(fmt.Sprintf("num_accounts=%d", i), func(t *testing.T) {
 			morseStateExport := new(migrationtypes.MorseStateExport)
-			stateExportBz, _ := newMorseStateExportAndAccountState(t, i)
+			stateExportBz, _ := testmigration.NewMorseStateExportAndAccountStateBytes(t, i)
 			err := cmtjson.Unmarshal(stateExportBz, morseStateExport)
 			require.NoError(t, err)
 
@@ -83,7 +78,7 @@ func BenchmarkTransformMorseState(b *testing.B) {
 	for i := 0; i < 5; i++ {
 		numAccounts := int(math.Pow10(i + 1))
 		morseStateExport := new(migrationtypes.MorseStateExport)
-		morseStateExportBz, _ := newMorseStateExportAndAccountState(b, numAccounts)
+		morseStateExportBz, _ := testmigration.NewMorseStateExportAndAccountStateBytes(b, numAccounts)
 		err := cmtjson.Unmarshal(morseStateExportBz, morseStateExport)
 		require.NoError(b, err)
 
@@ -99,91 +94,3 @@ func BenchmarkTransformMorseState(b *testing.B) {
 		})
 	}
 }
-
-// TODO_CONSIDERATION: Test/benchmark execution speed can be optimized by refactoring this to a pre-generate fixture.
-func newMorseStateExportAndAccountState(
-	t gocuke.TestingT,
-	numAccounts int,
-) (morseStateExportBz []byte, morseAccountStateBz []byte) {
-	morseStateExport := &migrationtypes.MorseStateExport{
-		AppHash: "",
-		AppState: &migrationtypes.MorseTendermintAppState{
-			Application: &migrationtypes.MorseApplications{},
-			Auth:        &migrationtypes.MorseAuth{},
-			Pos:         &migrationtypes.MorsePos{},
-		},
-	}
-
-	morseAccountState := &migrationtypes.MorseAccountState{
-		Accounts: make([]*migrationtypes.MorseAccount, numAccounts),
-	}
-
-	for i := 1; i < numAccounts+1; i++ {
-		seedUint := rand.Uint64()
-		seedBz := make([]byte, 8)
-		binary.LittleEndian.PutUint64(seedBz, seedUint)
-		privKey := cometcrypto.GenPrivKeyFromSecret(seedBz)
-		pubKey := privKey.PubKey()
-		balanceAmount := int64(1e6*i + i)                                 // i_000_00i
-		appStakeAmount := int64(1e5*i + (i * 10))                         //   i00_0i0
-		supplierStakeAmount := int64(1e4*i + (i * 100))                   //    i0_i00
-		sumAmount := balanceAmount + appStakeAmount + supplierStakeAmount // i_ii0_iii
-
-		// Add an account.
-		morseStateExport.AppState.Auth.Accounts = append(
-			morseStateExport.AppState.Auth.Accounts,
-			&migrationtypes.MorseAuthAccount{
-				Type: "posmint/Account",
-				Value: &migrationtypes.MorseAccount{
-					Address: pubKey.Address(),
-					Coins:   cosmostypes.NewCoins(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, balanceAmount)),
-					PubKey: &migrationtypes.MorsePublicKey{
-						Value: pubKey.Bytes(),
-					},
-				},
-			},
-		)
-
-		// Add an application.
-		morseStateExport.AppState.Application.Applications = append(
-			morseStateExport.AppState.Application.Applications,
-			&migrationtypes.MorseApplication{
-				Address:      pubKey.Address(),
-				PublicKey:    pubKey.Bytes(),
-				Jailed:       false,
-				Status:       2,
-				StakedTokens: fmt.Sprintf("%d", appStakeAmount),
-			},
-		)
-
-		// Add a supplier.
-		morseStateExport.AppState.Pos.Validators = append(
-			morseStateExport.AppState.Pos.Validators,
-			&migrationtypes.MorseValidator{
-				Address:      pubKey.Address(),
-				PublicKey:    pubKey.Bytes(),
-				Jailed:       false,
-				Status:       2,
-				StakedTokens: fmt.Sprintf("%d", supplierStakeAmount),
-			},
-		)
-
-		// Add the account to the morseAccountState.
-		morseAccountState.Accounts[i-1] = &migrationtypes.MorseAccount{
-			Address: pubKey.Address(),
-			Coins:   cosmostypes.NewCoins(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, sumAmount)),
-			PubKey: &migrationtypes.MorsePublicKey{
-				Value: pubKey.Bytes(),
-			},
-		}
-	}
-
-	var err error
-	morseStateExportBz, err = cmtjson.Marshal(morseStateExport)
-	require.NoError(t, err)
-
-	morseAccountStateBz, err = cmtjson.Marshal(morseAccountState)
-	require.NoError(t, err)
-
-	return morseStateExportBz, morseAccountStateBz
-}

proto/poktroll/migration/event.proto

@@ -0,0 +1,25 @@
+syntax = "proto3";
+package poktroll.migration;
+
+option go_package = "github.com/pokt-network/poktroll/x/migration/types";
+option (gogoproto.stable_marshaler_all) = true;
+
+import "cosmos_proto/cosmos.proto";
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+import "poktroll/shared/service.proto";
+import "poktroll/migration/morse_onchain.proto";
+
+// EventUploadMorseState is emitted when the MorseAccountState is created on-chain.
+message EventCreateMorseAccountState {
+  // The height (on Shannon) at which the MorseAccountState was created on-chain.
+  int64 created_at_height = 1 [(gogoproto.jsontag) = "created_at_height"];
+
+  // The sha256 has of the MorseAccountState.
+  bytes morse_account_state_hash = 2 [(gogoproto.jsontag) = "morse_account_state_hash"];
+
+  // The number of accounts (EOAs) which were collected from the Morse state export, which may be claimed.
+  // NOTE: Application and supplier actor stakes are consolidated into their corresponding account balances.
+  uint64 num_accounts = 3 [(gogoproto.jsontag) = "num_accounts"];
+}

testutil/testmigration/fixtures.go

@@ -0,0 +1,132 @@
+package testmigration
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+
+	cometcrypto "github.com/cometbft/cometbft/crypto/ed25519"
+	cmtjson "github.com/cometbft/cometbft/libs/json"
+	cosmostypes "github.com/cosmos/cosmos-sdk/types"
+	"github.com/regen-network/gocuke"
+	"github.com/stretchr/testify/require"
+
+	"github.com/pokt-network/poktroll/app/volatile"
+	migrationtypes "github.com/pokt-network/poktroll/x/migration/types"
+)
+
+// NewMorseStateExportAndAccountStateBytes returns:
+//   - A serialized MorseStateExport.
+//     This is the JSON output of `pocket util export-genesis-for-reset`.
+//     It is used to generate the MorseAccountState.
+//   - Its corresponding MorseAccountState.
+//     This is the JSON output of `poktrolld migrate collect-morse-accounts`.
+//     It is used to persist the canonical Morse migration state from on Shannon.
+//
+// The states are populated with:
+// - Random account addresses
+// - Monotonically increasing balances/stakes
+// - One application per account
+// - One supplier per account
+func NewMorseStateExportAndAccountStateBytes(
+	t gocuke.TestingT,
+	numAccounts int,
+) (morseStateExportBz []byte, morseAccountStateBz []byte) {
+	morseStateExport, morseAccountState := NewMorseStateExportAndAccountState(t, numAccounts)
+
+	var err error
+	morseStateExportBz, err = cmtjson.Marshal(morseStateExport)
+	require.NoError(t, err)
+
+	morseAccountStateBz, err = cmtjson.Marshal(morseAccountState)
+	require.NoError(t, err)
+
+	return morseStateExportBz, morseAccountStateBz
+}
+
+// NewMorseStateExportAndAccountState returns MorseStateExport and MorseAccountState
+// structs populated with:
+//   - Random account addresses
+//   - Monotonically increasing balances/stakes
+//   - One application per account
+//   - One supplier per account
+func NewMorseStateExportAndAccountState(
+	t gocuke.TestingT, numAccounts int,
+) (export *migrationtypes.MorseStateExport, state *migrationtypes.MorseAccountState) {
+	t.Helper()
+
+	morseStateExport := &migrationtypes.MorseStateExport{
+		AppHash: "",
+		AppState: &migrationtypes.MorseTendermintAppState{
+			Application: &migrationtypes.MorseApplications{},
+			Auth:        &migrationtypes.MorseAuth{},
+			Pos:         &migrationtypes.MorsePos{},
+		},
+	}
+
+	morseAccountState := &migrationtypes.MorseAccountState{
+		Accounts: make([]*migrationtypes.MorseAccount, numAccounts),
+	}
+
+	for i := 1; i < numAccounts+1; i++ {
+		seedUint := rand.Uint64()
+		seedBz := make([]byte, 8)
+		binary.LittleEndian.PutUint64(seedBz, seedUint)
+		privKey := cometcrypto.GenPrivKeyFromSecret(seedBz)
+		pubKey := privKey.PubKey()
+		balanceAmount := int64(1e6*i + i)                                 // i_000_00i
+		appStakeAmount := int64(1e5*i + (i * 10))                         //   i00_0i0
+		supplierStakeAmount := int64(1e4*i + (i * 100))                   //    i0_i00
+		sumAmount := balanceAmount + appStakeAmount + supplierStakeAmount // i_ii0_iii
+
+		// Add an account.
+		morseStateExport.AppState.Auth.Accounts = append(
+			morseStateExport.AppState.Auth.Accounts,
+			&migrationtypes.MorseAuthAccount{
+				Type: "posmint/Account",
+				Value: &migrationtypes.MorseAccount{
+					Address: pubKey.Address(),
+					Coins:   cosmostypes.NewCoins(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, balanceAmount)),
+					PubKey: &migrationtypes.MorsePublicKey{
+						Value: pubKey.Bytes(),
+					},
+				},
+			},
+		)
+
+		// Add an application.
+		morseStateExport.AppState.Application.Applications = append(
+			morseStateExport.AppState.Application.Applications,
+			&migrationtypes.MorseApplication{
+				Address:      pubKey.Address(),
+				PublicKey:    pubKey.Bytes(),
+				Jailed:       false,
+				Status:       2,
+				StakedTokens: fmt.Sprintf("%d", appStakeAmount),
+			},
+		)
+
+		// Add a supplier.
+		morseStateExport.AppState.Pos.Validators = append(
+			morseStateExport.AppState.Pos.Validators,
+			&migrationtypes.MorseValidator{
+				Address:      pubKey.Address(),
+				PublicKey:    pubKey.Bytes(),
+				Jailed:       false,
+				Status:       2,
+				StakedTokens: fmt.Sprintf("%d", supplierStakeAmount),
+			},
+		)
+
+		// Add the account to the morseAccountState.
+		morseAccountState.Accounts[i-1] = &migrationtypes.MorseAccount{
+			Address: pubKey.Address(),
+			Coins:   cosmostypes.NewCoins(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, sumAmount)),
+			PubKey: &migrationtypes.MorsePublicKey{
+				Value: pubKey.Bytes(),
+			},
+		}
+	}
+
+	return morseStateExport, morseAccountState
+}

x/migration/keeper/msg_server_morse_account_state.go

@@ -3,34 +3,54 @@ package keeper
 import (
 	"context"
 
-	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
-	"github.com/pokt-network/poktroll/x/migration/types"
+	migrationtypes "github.com/pokt-network/poktroll/x/migration/types"
 )
 
 // CreateMorseAccountState creates the on-chain MorseAccountState ONLY ONCE (per network / re-genesis).
-func (k msgServer) CreateMorseAccountState(goCtx context.Context, msg *types.MsgCreateMorseAccountState) (*types.MsgCreateMorseAccountStateResponse, error) {
-	ctx := sdk.UnwrapSDKContext(goCtx)
+func (k msgServer) CreateMorseAccountState(
+	ctx context.Context,
+	msg *migrationtypes.MsgCreateMorseAccountState,
+) (*migrationtypes.MsgCreateMorseAccountStateResponse, error) {
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	logger := sdkCtx.Logger().With("method", "CreateMorseAccountState")
 
-	// Check if the value already exists
-	_, isFound := k.GetMorseAccountState(ctx)
-	if isFound {
-		return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "already set")
+	if err := msg.ValidateBasic(); err != nil {
+		logger.Info(err.Error())
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
-	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+	// Check if the value already exists
+	if _, isFound := k.GetMorseAccountState(sdkCtx); isFound {
+		err := migrationtypes.ErrMorseAccountState.Wrap("already set")
+		logger.Info(err.Error())
+		return nil, status.Error(codes.FailedPrecondition, err.Error())
 	}
 
-	k.SetMorseAccountState(
-		ctx,
-		msg.MorseAccountState,
-	)
+	k.SetMorseAccountState(sdkCtx, msg.MorseAccountState)
 
-	// TODO_UPNEXT(@bryanchriswhite#1034): Emit an event...
+	stateHash, err := msg.MorseAccountState.GetHash()
+	if err != nil {
+		logger.Info(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	if err = sdkCtx.EventManager().EmitTypedEvent(
+		&migrationtypes.EventCreateMorseAccountState{
+			CreatedAtHeight:       sdkCtx.BlockHeight(),
+			MorseAccountStateHash: stateHash,
+			NumAccounts:           uint64(len(msg.MorseAccountState.Accounts)),
+		},
+	); err != nil {
+		logger.Info(err.Error())
+		return nil, err
+	}
 
-	// TODO_UPNEXT(@bryanchriswhite#1034): Populate the response...
-	return &types.MsgCreateMorseAccountStateResponse{}, nil
+	return &migrationtypes.MsgCreateMorseAccountStateResponse{
+		StateHash:   stateHash,
+		NumAccounts: uint64(len(msg.MorseAccountState.Accounts)),
+	}, nil
 }