feat(gno.land): support setting custom height/timestamp for genesis txs

gno.land/pkg/gnoland/app.go

@@ -2,6 +2,7 @@
 package gnoland
 
 import (
+	"errors"
 	"fmt"
 	"log/slog"
 	"path/filepath"
@@ -71,6 +72,7 @@ func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
 	if err := cfg.validate(); err != nil {
 		return nil, err
 	}
+	cfg.setDefaults()
 
 	// Capabilities keys.
 	mainKey := store.NewStoreKey("main")
@@ -121,6 +123,9 @@ func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
 	// the tx - in other words, data from a failing transaction won't be persisted
 	// to the gno store caches.
 	baseApp.SetBeginTxHook(func(ctx sdk.Context) sdk.Context {
+		if icc.beginTxHook != nil && ctx.BlockHeight() == 0 {
+			ctx = icc.beginTxHook(ctx)
+		}
 		// Create Gno transaction store.
 		return vmk.MakeGnoTransactionStore(ctx)
 	})
@@ -229,10 +234,16 @@ type InitChainerConfig struct {
 	vmKpr   vm.VMKeeperI
 	acctKpr auth.AccountKeeperI
 	bankKpr bank.BankKeeperI
+
+	// This is used by InitChainer, to set a different beginTxHook on each
+	// transaction. This allows the InitChainer to pass additional data down
+	// to the underlying app, such as custom Time/Height for genesis.
+	// (See [GnoGenesisState]).
+	beginTxHook func(sdk.Context) sdk.Context
 }
 
 // InitChainer is the function that can be used as a [sdk.InitChainer].
-func (cfg InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
+func (cfg *InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
 	start := time.Now()
 	ctx.Logger().Debug("InitChainer: started")
 
@@ -263,7 +274,7 @@ func (cfg InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitCh
 	}
 }
 
-func (cfg InitChainerConfig) loadStdlibs(ctx sdk.Context) {
+func (cfg *InitChainerConfig) loadStdlibs(ctx sdk.Context) {
 	// cache-wrapping is necessary for non-validator nodes; in the tm2 BaseApp,
 	// this is done using BaseApp.cacheTxContext; so we replicate it here.
 	ms := ctx.MultiStore()
@@ -281,7 +292,12 @@ func (cfg InitChainerConfig) loadStdlibs(ctx sdk.Context) {
 	msCache.MultiWrite()
 }
 
-func (cfg InitChainerConfig) loadAppState(ctx sdk.Context, appState any) ([]abci.ResponseDeliverTx, error) {
+func (cfg *InitChainerConfig) loadAppState(ctx sdk.Context, appState any) ([]abci.ResponseDeliverTx, error) {
+	defer func() {
+		// Ensure to reset beginTxHook to nil when wrapping up.
+		cfg.beginTxHook = nil
+	}()
+
 	state, ok := appState.(GnoGenesisState)
 	if !ok {
 		return nil, fmt.Errorf("invalid AppState of type %T", appState)
@@ -297,9 +313,23 @@ func (cfg InitChainerConfig) loadAppState(ctx sdk.Context, appState any) ([]abci
 		}
 	}
 
+	if len(state.TxContexts) != 0 && len(state.Txs) != len(state.TxContexts) {
+		return nil, errors.New("genesis state tx_contexts, if given, should be of same length as txs")
+	}
+
 	txResponses := make([]abci.ResponseDeliverTx, 0, len(state.Txs))
 	// Run genesis txs
-	for _, tx := range state.Txs {
+	for idx, tx := range state.Txs {
+		if len(state.TxContexts) > 0 {
+			customExecCtx := state.TxContexts[idx]
+			if customExecCtx.Timestamp == 0 {
+				customExecCtx.Timestamp = ctx.BlockTime().Unix()
+			}
+			cfg.beginTxHook = func(ctx sdk.Context) sdk.Context {
+				return vm.InjectExecContextCustom(ctx, customExecCtx)
+			}
+		}
+
 		res := cfg.baseApp.Deliver(tx)
 		if res.IsErr() {
 			ctx.Logger().Error(

gno.land/pkg/gnoland/app_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -26,6 +27,18 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func testRequestInitChain(genState GnoGenesisState) abci.RequestInitChain {
+	return abci.RequestInitChain{
+		Time:    time.Now(),
+		ChainID: "dev",
+		ConsensusParams: &abci.ConsensusParams{
+			Block: defaultBlockParams(),
+		},
+		Validators: []abci.ValidatorUpdate{},
+		AppState:   genState,
+	}
+}
+
 // Tests that NewAppWithOptions works even when only providing a simple DB.
 func TestNewAppWithOptions(t *testing.T) {
 	t.Parallel()
@@ -37,34 +50,26 @@ func TestNewAppWithOptions(t *testing.T) {
 	assert.Equal(t, "gnoland", bapp.Name())
 
 	addr := crypto.AddressFromPreimage([]byte("test1"))
-	resp := bapp.InitChain(abci.RequestInitChain{
-		Time:    time.Now(),
-		ChainID: "dev",
-		ConsensusParams: &abci.ConsensusParams{
-			Block: defaultBlockParams(),
-		},
-		Validators: []abci.ValidatorUpdate{},
-		AppState: GnoGenesisState{
-			Balances: []Balance{
-				{
-					Address: addr,
-					Amount:  []std.Coin{{Amount: 1e15, Denom: "ugnot"}},
-				},
+	resp := bapp.InitChain(testRequestInitChain(GnoGenesisState{
+		Balances: []Balance{
+			{
+				Address: addr,
+				Amount:  []std.Coin{{Amount: 1e15, Denom: "ugnot"}},
 			},
-			Txs: []std.Tx{
-				{
-					Msgs: []std.Msg{vm.NewMsgAddPackage(addr, "gno.land/r/demo", []*std.MemFile{
-						{
-							Name: "demo.gno",
-							Body: "package demo; func Hello() string { return `hello`; }",
-						},
-					})},
-					Fee:        std.Fee{GasWanted: 1e6, GasFee: std.Coin{Amount: 1e6, Denom: "ugnot"}},
-					Signatures: []std.Signature{{}}, // one empty signature
-				},
+		},
+		Txs: []std.Tx{
+			{
+				Msgs: []std.Msg{vm.NewMsgAddPackage(addr, "gno.land/r/demo", []*std.MemFile{
+					{
+						Name: "demo.gno",
+						Body: "package demo; func Hello() string { return `hello`; }",
+					},
+				})},
+				Fee:        std.Fee{GasWanted: 1e6, GasFee: std.Coin{Amount: 1e6, Denom: "ugnot"}},
+				Signatures: []std.Signature{{}}, // one empty signature
 			},
 		},
-	})
+	}))
 	require.True(t, resp.IsOK(), "InitChain response: %v", resp)
 
 	tx := amino.MustMarshal(std.Tx{
@@ -116,6 +121,115 @@ func TestNewApp(t *testing.T) {
 	assert.True(t, resp.IsOK(), "resp is not OK: %v", resp)
 }
 
+func TestNewAppWithOptions_WithTxContexts(t *testing.T) {
+	t.Parallel()
+
+	appOpts := TestAppOptions(memdb.NewMemDB())
+	called := 0
+	appOpts.GenesisTxResultHandler = func(ctx sdk.Context, _ std.Tx, res sdk.Result) {
+		if !res.IsOK() {
+			t.Fatal(res)
+		}
+		called++
+		switch called {
+		case 1:
+			assert.Equal(t, string(res.Data), "time.Now() 7331\nstd.GetHeight() -1337\n")
+		case 2:
+			assert.Equal(t, string(res.Data), "time.Now() "+strconv.FormatInt(ctx.BlockTime().Unix(), 10)+"\nstd.GetHeight() 13377331\n")
+		}
+	}
+	app, err := NewAppWithOptions(appOpts)
+	require.NoError(t, err)
+	bapp := app.(*sdk.BaseApp)
+
+	const pkgFile = `package main
+
+import (
+	"std"
+	"time"
+)
+
+func main() {
+	println("time.Now()", time.Now().Unix())
+	println("std.GetHeight()", std.GetHeight())
+}
+`
+
+	addr := crypto.AddressFromPreimage([]byte("test1"))
+	resp := bapp.InitChain(testRequestInitChain(GnoGenesisState{
+		Balances: []Balance{
+			{
+				Address: addr,
+				Amount:  []std.Coin{{Amount: 1e15, Denom: "ugnot"}},
+			},
+		},
+		Txs: []std.Tx{
+			{
+				Msgs: []std.Msg{vm.NewMsgRun(addr, std.Coins{}, []*std.MemFile{
+					{
+						Name: "demo.gno",
+						Body: pkgFile,
+					},
+				})},
+				Fee:        std.Fee{GasWanted: 1e6, GasFee: std.Coin{Amount: 1e6, Denom: "ugnot"}},
+				Signatures: []std.Signature{{}}, // one empty signature
+			},
+			{
+				// same as previous, but will have different TxContext.
+				Msgs: []std.Msg{vm.NewMsgRun(addr, std.Coins{}, []*std.MemFile{
+					{
+						Name: "demo.gno",
+						Body: pkgFile,
+					},
+				})},
+				Fee:        std.Fee{GasWanted: 1e6, GasFee: std.Coin{Amount: 1e6, Denom: "ugnot"}},
+				Signatures: []std.Signature{{}}, // one empty signature
+			},
+		},
+		TxContexts: []vm.ExecContextCustom{
+			{
+				Height:    -1337,
+				Timestamp: 7331,
+			},
+			{
+				// different height; timestamp=0 will mean that InitChain will auto-set it
+				// to the block time.
+				Height:    13377331,
+				Timestamp: 0,
+			},
+		},
+	}))
+	require.True(t, resp.IsOK(), "InitChain response: %v", resp)
+}
+
+func TestNewAppWithOptions_InvalidTxContexts(t *testing.T) {
+	t.Parallel()
+
+	app, err := NewAppWithOptions(testAppOptions())
+	require.NoError(t, err)
+	bapp := app.(*sdk.BaseApp)
+
+	addr := crypto.AddressFromPreimage([]byte("test1"))
+	resp := bapp.InitChain(testRequestInitChain(GnoGenesisState{
+		Balances: []Balance{
+			{
+				Address: addr,
+				Amount:  []std.Coin{{Amount: 1e15, Denom: "ugnot"}},
+			},
+		},
+		Txs: []std.Tx{
+			// one tx
+			{},
+		},
+		TxContexts: []vm.ExecContextCustom{
+			// two contexts
+			{}, {},
+		},
+	}))
+	assert.True(t, resp.IsErr())
+	assert.ErrorContains(t, resp.Error, "genesis state tx_contexts, if given, should be of same length as txs")
+}
+
 // Test whether InitChainer calls to load the stdlibs correctly.
 func TestInitChainer_LoadStdlib(t *testing.T) {
 	t.Parallel()

gno.land/pkg/gnoland/types.go

@@ -3,6 +3,7 @@ package gnoland
 import (
 	"errors"
 
+	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	"github.com/gnolang/gno/tm2/pkg/std"
 )
 
@@ -22,4 +23,6 @@ func ProtoGnoAccount() std.Account {
 type GnoGenesisState struct {
 	Balances []Balance `json:"balances"`
 	Txs      []std.Tx  `json:"txs"`
+	// Should match len(Txs), or be null
+	TxContexts []vm.ExecContextCustom `json:"tx_contexts"`
 }