feat: expose InitChain tx responses

gno.land/pkg/gnoland/app.go

@@ -193,6 +193,8 @@
 	resHandler GenesisTxHandler,
 ) func(sdk.Context, abci.RequestInitChain) abci.ResponseInitChain {
 	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
+		txResponses := []abci.ResponseDeliverTx{}
+
 		if req.AppState != nil {
 			// Get genesis state
 			genState := req.AppState.(GnoGenesisState)
@@ -219,13 +221,20 @@
 					)
 				}
 
+				txResponses = append(txResponses, abci.ResponseDeliverTx{
+					ResponseBase: res.ResponseBase,
+					GasWanted:    res.GasWanted,
+					GasUsed:      res.GasUsed,
+				})
+
 				resHandler(ctx, tx, res)
 			}
 		}
 
 		// Done!
 		return abci.ResponseInitChain{
-			Validators: req.Validators,
+			Validators:  req.Validators,
+			TxResponses: txResponses,
 		}
 	}
 }

tm2/pkg/bft/abci/types/abci.proto

@@ -112,6 +112,7 @@ message ResponseInitChain {
 	ResponseBase response_base = 1 [json_name = "ResponseBase"];
 	ConsensusParams consensus_params = 2 [json_name = "ConsensusParams"];
 	repeated ValidatorUpdate validators = 3 [json_name = "Validators"];
+	repeated ResponseDeliverTx tx_responses = 4 [json_name = "TxResponses"];
 }
 
 message ResponseQuery {

tm2/pkg/bft/abci/types/testing/mock_application.go

@@ -0,0 +1,91 @@
+package testing
+
+import abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
+
+type MockApplication struct {
+	abci.BaseApplication
+	InfoFn       func(abci.RequestInfo) abci.ResponseInfo
+	SetOptionFn  func(abci.RequestSetOption) abci.ResponseSetOption
+	QueryFn      func(abci.RequestQuery) abci.ResponseQuery
+	CheckTxFn    func(abci.RequestCheckTx) abci.ResponseCheckTx
+	InitChainFn  func(abci.RequestInitChain) abci.ResponseInitChain
+	BeginBlockFn func(abci.RequestBeginBlock) abci.ResponseBeginBlock
+	DeliverTxFn  func(abci.RequestDeliverTx) abci.ResponseDeliverTx
+	EndBlockFn   func(abci.RequestEndBlock) abci.ResponseEndBlock
+	CommitFn     func() abci.ResponseCommit
+	CloseFn      func() error
+}
+
+// Info/Query Connection
+func (app *MockApplication) Info(req abci.RequestInfo) abci.ResponseInfo {
+	if app.InfoFn != nil {
+		return app.InfoFn(req)
+	}
+	return abci.ResponseInfo{}
+}
+
+func (app *MockApplication) SetOption(req abci.RequestSetOption) abci.ResponseSetOption {
+	if app.SetOptionFn != nil {
+		return app.SetOptionFn(req)
+	}
+	return abci.ResponseSetOption{}
+}
+
+func (app *MockApplication) Query(req abci.RequestQuery) abci.ResponseQuery {
+	if app.QueryFn != nil {
+		return app.QueryFn(req)
+	}
+	return abci.ResponseQuery{}
+}
+
+// Mempool Connection
+func (app *MockApplication) CheckTx(req abci.RequestCheckTx) abci.ResponseCheckTx {
+	if app.CheckTxFn != nil {
+		return app.CheckTxFn(req)
+	}
+	return abci.ResponseCheckTx{}
+}
+
+// Consensus Connection
+func (app *MockApplication) InitChain(req abci.RequestInitChain) abci.ResponseInitChain {
+	if app.InitChainFn != nil {
+		return app.InitChainFn(req)
+	}
+	return abci.ResponseInitChain{}
+}
+
+func (app *MockApplication) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlock {
+	if app.BeginBlockFn != nil {
+		return app.BeginBlockFn(req)
+	}
+	return abci.ResponseBeginBlock{}
+}
+
+func (app *MockApplication) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx {
+	if app.DeliverTxFn != nil {
+		return app.DeliverTxFn(req)
+	}
+	return abci.ResponseDeliverTx{}
+}
+
+func (app *MockApplication) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlock {
+	if app.EndBlockFn != nil {
+		return app.EndBlockFn(req)
+	}
+	return abci.ResponseEndBlock{}
+}
+
+func (app *MockApplication) Commit() abci.ResponseCommit {
+	if app.CommitFn != nil {
+		return app.CommitFn()
+	}
+	return abci.ResponseCommit{}
+}
+
+// Cleanup
+func (app *MockApplication) Close() error {
+	if app.CloseFn != nil {
+		return app.CloseFn()
+	}
+	return nil
+}

tm2/pkg/bft/abci/types/types.go

@@ -159,6 +159,7 @@ type ResponseInitChain struct {
 	ResponseBase
 	ConsensusParams *ConsensusParams
 	Validators      []ValidatorUpdate
+	TxResponses     []ResponseDeliverTx
 }
 
 type ResponseQuery struct {

tm2/pkg/bft/consensus/replay.go

@@ -307,6 +307,13 @@ func (h *Handshaker) ReplayBlocks(
 			return nil, err
 		}
 
+		// Save the results by height
+		abciResponse := sm.NewABCIResponsesFromNum(int64(len(res.TxResponses)))
+		copy(abciResponse.DeliverTxs, res.TxResponses)
+		sm.SaveABCIResponses(h.stateDB, 0, abciResponse)
+
+		// NOTE: we don't save results by tx hash since the transactions are in the AppState opaque type
+
 		if stateBlockHeight == 0 { // we only update state when we are in initial state
 			// If the app returned validators or consensus params, update the state.
 			if len(res.Validators) > 0 {

tm2/pkg/bft/consensus/replay_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	"github.com/gnolang/gno/tm2/pkg/bft/abci/example/kvstore"
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
+	abci_testing "github.com/gnolang/gno/tm2/pkg/bft/abci/types/testing"
 	"github.com/gnolang/gno/tm2/pkg/bft/appconn"
 	cfg "github.com/gnolang/gno/tm2/pkg/bft/config"
 	cstypes "github.com/gnolang/gno/tm2/pkg/bft/consensus/types"
@@ -1131,11 +1132,19 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 
 	val, _ := types.RandValidator(true, 10)
 	vals := types.NewValidatorSet([]*types.Validator{val})
-	app := &initChainApp{vals: vals.ABCIValidatorUpdates()}
+	appVals := vals.ABCIValidatorUpdates()
+	// returns the vals on InitChain
+	app := &abci_testing.MockApplication{
+		InitChainFn: func(req abci.RequestInitChain) abci.ResponseInitChain {
+			return abci.ResponseInitChain{
+				Validators: appVals,
+			}
+		},
+	}
 	clientCreator := proxy.NewLocalClientCreator(app)
 
 	config, genesisFile := ResetConfig("handshake_test_")
-	defer os.RemoveAll(config.RootDir)
+	t.Cleanup(func() { require.NoError(t, os.RemoveAll(config.RootDir)) })
 	stateDB, state, store := makeStateAndStore(config, genesisFile, "v0.0.0-test")
 
 	oldValAddr := state.Validators.Validators[0].Address
@@ -1144,13 +1153,9 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	genDoc, _ := sm.MakeGenesisDocFromFile(genesisFile)
 	handshaker := NewHandshaker(stateDB, state, store, genDoc)
 	proxyApp := appconn.NewAppConns(clientCreator)
-	if err := proxyApp.Start(); err != nil {
-		t.Fatalf("Error starting proxy app connections: %v", err)
-	}
-	defer proxyApp.Stop()
-	if err := handshaker.Handshake(proxyApp); err != nil {
-		t.Fatalf("Error on abci handshake: %v", err)
-	}
+	require.NoError(t, proxyApp.Start(), "Error starting proxy app connections")
+	t.Cleanup(func() { require.NoError(t, proxyApp.Stop()) })
+	require.NoError(t, handshaker.Handshake(proxyApp), "Error on abci handshake")
 
 	// reload the state, check the validator set was updated
 	state = sm.LoadState(stateDB)
@@ -1161,14 +1166,34 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	assert.Equal(t, newValAddr, expectValAddr)
 }
 
-// returns the vals on InitChain
-type initChainApp struct {
-	abci.BaseApplication
-	vals []abci.ValidatorUpdate
-}
+func TestHandshakeGenesisResponseDeliverTx(t *testing.T) {
+	t.Parallel()
+
+	const numInitResponses = 42
 
-func (ica *initChainApp) InitChain(req abci.RequestInitChain) abci.ResponseInitChain {
-	return abci.ResponseInitChain{
-		Validators: ica.vals,
+	app := &abci_testing.MockApplication{
+		InitChainFn: func(req abci.RequestInitChain) abci.ResponseInitChain {
+			return abci.ResponseInitChain{
+				TxResponses: make([]abci.ResponseDeliverTx, numInitResponses),
+			}
+		},
 	}
+	clientCreator := proxy.NewLocalClientCreator(app)
+
+	config, genesisFile := ResetConfig("handshake_test_")
+	t.Cleanup(func() { require.NoError(t, os.RemoveAll(config.RootDir)) })
+	stateDB, state, store := makeStateAndStore(config, genesisFile, "v0.0.0-test")
+
+	// now start the app using the handshake - it should sync
+	genDoc, _ := sm.MakeGenesisDocFromFile(genesisFile)
+	handshaker := NewHandshaker(stateDB, state, store, genDoc)
+	proxyApp := appconn.NewAppConns(clientCreator)
+	require.NoError(t, proxyApp.Start(), "Error starting proxy app connections")
+	t.Cleanup(func() { require.NoError(t, proxyApp.Stop()) })
+	require.NoError(t, handshaker.Handshake(proxyApp), "Error on abci handshake")
+
+	// check that the genesis transaction results are saved
+	res, err := sm.LoadABCIResponses(stateDB, 0)
+	require.NoError(t, err, "Failed to load genesis ABCI responses")
+	assert.Len(t, res.DeliverTxs, numInitResponses)
 }

tm2/pkg/bft/rpc/core/blocks.go

@@ -236,7 +236,7 @@
 // ```
 func Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlock, error) {
 	storeHeight := blockStore.Height()
-	height, err := getHeight(storeHeight, heightPtr)
+	height, err := getHeight(storeHeight, heightPtr, 1)
 	if err != nil {
 		return nil, err
 	}
@@ -327,7 +327,7 @@
 // ```
 func Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, error) {
 	storeHeight := blockStore.Height()
-	height, err := getHeight(storeHeight, heightPtr)
+	height, err := getHeight(storeHeight, heightPtr, 1)
 	if err != nil {
 		return nil, err
 	}
@@ -400,7 +400,7 @@
 // ```
 func BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlockResults, error) {
 	storeHeight := blockStore.Height()
-	height, err := getHeight(storeHeight, heightPtr)
+	height, err := getHeight(storeHeight, heightPtr, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -417,11 +417,11 @@
 	return res, nil
 }
 
-func getHeight(currentHeight int64, heightPtr *int64) (int64, error) {
+func getHeight(currentHeight int64, heightPtr *int64, min int64) (int64, error) {
 	if heightPtr != nil {
 		height := *heightPtr
-		if height <= 0 {
-			return 0, fmt.Errorf("height must be greater than 0")
+		if height < min {
+			return 0, fmt.Errorf("height must be greater than or equal to %d", min)
 		}
 		if height > currentHeight {
 			return 0, fmt.Errorf("height must be less than or equal to the current blockchain height")

tm2/pkg/bft/rpc/core/blocks_test.go

@@ -55,3 +55,40 @@ func TestBlockchainInfo(t *testing.T) {
 		}
 	}
 }
+
+func TestGetHeight(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		currentHeight int64
+		heightPtr     *int64
+		min           int64
+		res           int64
+		wantErr       bool
+	}{
+		// height >= min
+		{42, int64Ptr(0), 0, 0, false},
+		{42, int64Ptr(1), 0, 1, false},
+
+		// height < min
+		{42, int64Ptr(0), 1, 0, true},
+
+		// nil height
+		{42, nil, 1, 42, false},
+	}
+
+	for i, c := range cases {
+		caseString := fmt.Sprintf("test %d failed", i)
+		res, err := getHeight(c.currentHeight, c.heightPtr, c.min)
+		if c.wantErr {
+			require.Error(t, err, caseString)
+		} else {
+			require.NoError(t, err, caseString)
+			require.Equal(t, res, c.res, caseString)
+		}
+	}
+}
+
+func int64Ptr(v int64) *int64 {
+	return &v
+}

tm2/pkg/bft/rpc/core/consensus.go

@@ -58,7 +58,7 @@
 	// The latest validator that we know is the
 	// NextValidator of the last block.
 	height := consensusState.GetState().LastBlockHeight + 1
-	height, err := getHeight(height, heightPtr)
+	height, err := getHeight(height, heightPtr, 1)
 	if err != nil {
 		return nil, err
 	}
@@ -344,7 +344,7 @@
 // ```
 func ConsensusParams(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultConsensusParams, error) {
 	height := consensusState.GetState().LastBlockHeight + 1
-	height, err := getHeight(height, heightPtr)
+	height, err := getHeight(height, heightPtr, 1)
 	if err != nil {
 		return nil, err
 	}

tm2/pkg/bft/rpc/core/tx.go

@@ -19,7 +19,7 @@ func Tx(_ *rpctypes.Context, hash []byte) (*ctypes.ResultTx, error) {
 	}
 
 	// Sanity check the block height
-	height, err := getHeight(blockStore.Height(), &resultIndex.BlockNum)
+	height, err := getHeight(blockStore.Height(), &resultIndex.BlockNum, 1)
 	if err != nil {
 		return nil, err
 	}

tm2/pkg/bft/state/execution.go

@@ -106,10 +106,10 @@ func (blockExec *BlockExecutor) ApplyBlock(state State, blockID types.BlockID, b
 
 	fail.Fail() // XXX
 
-	// Save the results before we commit.
-	saveABCIResponses(blockExec.db, block.Height, abciResponses)
+	// Save the results by height
+	SaveABCIResponses(blockExec.db, block.Height, abciResponses)
 
-	// Save the transaction results
+	// Save the results by tx hash
 	for index, tx := range block.Txs {
 		saveTxResultIndex(
 			blockExec.db,

tm2/pkg/bft/state/export_test.go

@@ -42,12 +42,6 @@ func CalcValidatorsKey(height int64) []byte {
 	return calcValidatorsKey(height)
 }
 
-// SaveABCIResponses is an alias for the private saveABCIResponses method in
-// store.go, exported exclusively and explicitly for testing.
-func SaveABCIResponses(db dbm.DB, height int64, abciResponses *ABCIResponses) {
-	saveABCIResponses(db, height, abciResponses)
-}
-
 // SaveConsensusParamsInfo is an alias for the private saveConsensusParamsInfo
 // method in store.go, exported exclusively and explicitly for testing.
 func SaveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params abci.ConsensusParams) {