feat: transactions in the same block have different timestamps

examples/gno.land/r/demo/deep/very/deep/render.gno

@@ -1,9 +1,15 @@
 package deep
 
+import "time"
+
 func Render(path string) string {
 	if path == "" {
 		return "it works!"
 	} else {
 		return "hi " + path
 	}
 }
+
+func CurrentTimeUnixNano() int64 {
+	return time.Now().UnixNano()
+}

gno.land/pkg/gnoclient/client_txs.go

@@ -228,7 +228,6 @@ func (c *Client) Send(cfg BaseTxCfg, msgs ...MsgSend) (*ctypes.ResultBroadcastTx
 // signAndBroadcastTxCommit signs a transaction and broadcasts it, returning the result.
 func (c Client) signAndBroadcastTxCommit(tx std.Tx, accountNumber, sequenceNumber uint64) (*ctypes.ResultBroadcastTxCommit, error) {
 	caller := c.Signer.Info().GetAddress()
-
 	if sequenceNumber == 0 || accountNumber == 0 {
 		account, _, err := c.QueryAccount(caller)
 		if err != nil {

gno.land/pkg/gnoclient/integration_test.go

@@ -1,28 +1,35 @@
 package gnoclient
 
 import (
+	"strconv"
+	"strings"
+	"sync"
 	"testing"
 
 	"github.com/gnolang/gno/tm2/pkg/std"
 
+	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/gno.land/pkg/integration"
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	rpcclient "github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
+	core_types "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
 	"github.com/gnolang/gno/tm2/pkg/log"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+const testChainID string = "tendermint_test"
+
 func TestCallSingle_Integration(t *testing.T) {
 	// Set up in-memory node
 	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
 	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNoopLogger(), config)
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	// Setup Client
@@ -65,7 +72,7 @@ func TestCallMultiple_Integration(t *testing.T) {
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	// Setup Client
@@ -109,14 +116,126 @@ func TestCallMultiple_Integration(t *testing.T) {
 	assert.Equal(t, expected, got)
 }
 
+func TestMultiTxTimestamp_Integration(t *testing.T) {
+	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
+	keybase := keys.NewInMemory()
+	signerOne := defaultInMemorySigner(t, testChainID)
+
+	newAccountMnemonic := "when school roof tomato organ middle bring smile rebuild faith chase fragile increase paddle cool pink model become nation abuse advice sword mimic reduce"
+	signerTwo := newInMemorySigner(t, testChainID, keybase, newAccountMnemonic, "test2")
+	config.AddGenesisBalances(
+		gnoland.Balance{
+			Address: signerTwo.Address,
+			Amount: std.Coins{
+				std.Coin{
+					Denom:  "ugnot",
+					Amount: 1000000000,
+				},
+			},
+		},
+	)
+
+	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNoopLogger(), config)
+	defer node.Stop()
+	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
+
+	clientOne := Client{
+		Signer:    signerOne,
+		RPCClient: rpcClient,
+	}
+	clientTwo := Client{
+		Signer:    signerTwo,
+		RPCClient: rpcClient,
+	}
+
+	type callRes struct {
+		result *core_types.ResultBroadcastTxCommit
+		err    error
+	}
+
+	maxTries := 5
+	for i := 1; i <= maxTries; i++ {
+		resCh := make(chan callRes, 2)
+		wg := new(sync.WaitGroup)
+		wg.Add(2)
+
+		sendTx := func(client Client) {
+			baseCfg := BaseTxCfg{
+				GasFee:    "10000ugnot",
+				GasWanted: 8000000,
+			}
+
+			// Make Msg configs
+			msg := MsgCall{
+				PkgPath:  "gno.land/r/demo/deep/very/deep",
+				FuncName: "CurrentTimeUnixNano",
+			}
+
+			res, err := client.Call(baseCfg, msg)
+			resCh <- callRes{result: res, err: err}
+			wg.Done()
+		}
+
+		go sendTx(clientOne)
+		go sendTx(clientTwo)
+		wg.Wait()
+		close(resCh)
+
+		results := make([]*core_types.ResultBroadcastTxCommit, 0, 2)
+		for res := range resCh {
+			if res.err != nil {
+				t.Errorf("unexpected error %v", res.err)
+			}
+			results = append(results, res.result)
+		}
+
+		if len(results) != 2 {
+			t.Errorf("expected 2 results, got %d", len(results))
+		}
+
+		if results[0].Height != results[1].Height {
+			if i < maxTries {
+				continue
+			}
+			t.Errorf("expected same height, got %d and %d", results[0].Height, results[1].Height)
+		}
+
+		extractInt := func(data []byte) int64 {
+			parts := strings.Split(string(data), " ")
+			numStr := parts[0][1:]
+			num, err := strconv.ParseInt(numStr, 10, 64)
+			if err != nil {
+				t.Errorf("unable to parse number from string %s", string(data))
+			}
+
+			return num
+		}
+
+		time1, time2 := extractInt(results[0].DeliverTx.Data), extractInt(results[1].DeliverTx.Data)
+		diff := time1 - time2
+		if diff < 0 {
+			diff *= -1
+		}
+
+		if diff != 100 {
+			if i < maxTries {
+				continue
+			}
+			t.Errorf("expected time difference to be 100, got %d", diff)
+		}
+
+		break
+	}
+}
+
 func TestSendSingle_Integration(t *testing.T) {
 	// Set up in-memory node
 	config, _ := integration.TestingNodeConfig(t, gnoenv.RootDir())
 	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNoopLogger(), config)
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	// Setup Client
@@ -164,7 +283,7 @@ func TestSendMultiple_Integration(t *testing.T) {
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	// Setup Client
@@ -220,7 +339,7 @@ func TestRunSingle_Integration(t *testing.T) {
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	client := Client{
@@ -278,7 +397,7 @@ func TestRunMultiple_Integration(t *testing.T) {
 	defer node.Stop()
 
 	// Init Signer & RPCClient
-	signer := newInMemorySigner(t, "tendermint_test")
+	signer := defaultInMemorySigner(t, "tendermint_test")
 	rpcClient := rpcclient.NewHTTP(remoteAddr, "/websocket")
 
 	client := Client{
@@ -355,20 +474,26 @@ func main() {
 // MsgCall with Send field populated (single/multiple)
 // MsgRun with Send field populated (single/multiple)
 
-func newInMemorySigner(t *testing.T, chainid string) *SignerFromKeybase {
+func defaultInMemorySigner(t *testing.T, chainID string) *SignerFromKeybase {
 	t.Helper()
 
-	mnemonic := integration.DefaultAccount_Seed
-	name := integration.DefaultAccount_Name
+	keybase := keys.NewInMemory()
+	return newInMemorySigner(t, chainID, keybase, integration.DefaultAccount_Seed, integration.DefaultAccount_Name)
+}
+
+func newInMemorySigner(t *testing.T, chainID string, keybase keys.Keybase, mnemonic, name string) *SignerFromKeybase {
+	t.Helper()
 
-	kb := keys.NewInMemory()
-	_, err := kb.CreateAccount(name, mnemonic, "", "", uint32(0), uint32(0))
-	require.NoError(t, err)
+	info, err := keybase.CreateAccount(name, mnemonic, "", "", 0, 0)
+	if err != nil {
+		t.Fatalf("unexpected error getting new signer: %v", err)
+	}
 
 	return &SignerFromKeybase{
-		Keybase:  kb,      // Stores keys in memory or on disk
+		Keybase:  keybase, // Stores keys in memory or on disk
 		Account:  name,    // Account name or bech32 format
+		Address:  info.GetAddress(),
 		Password: "",      // Password for encryption
-		ChainID:  chainid, // Chain ID for transaction signing
+		ChainID:  chainID, // Chain ID for transaction signing
 	}
 }

gno.land/pkg/gnoclient/signer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
 	"github.com/gnolang/gno/tm2/pkg/errors"
 	"github.com/gnolang/gno/tm2/pkg/std"
@@ -19,9 +20,10 @@ type Signer interface {
 // SignerFromKeybase represents a signer created from a Keybase.
 type SignerFromKeybase struct {
 	Keybase  keys.Keybase // Stores keys in memory or on disk
-	Account  string       // Account name or bech32 format
+	Account  string       // Account name
 	Password string       // Password for encryption
 	ChainID  string       // Chain ID for transaction signing
+	Address  crypto.Address
 }
 
 func (s SignerFromKeybase) Validate() error {

gno.land/pkg/gnoland/node_inmemory.go

@@ -27,6 +27,21 @@ type InMemoryNodeConfig struct {
 	GenesisMaxVMCycles    int64
 }
 
+func (cfg *InMemoryNodeConfig) AddGenesisBalances(balances ...Balance) error {
+	var (
+		genesisState GnoGenesisState
+		ok           bool
+	)
+
+	if genesisState, ok = cfg.Genesis.AppState.(GnoGenesisState); !ok {
+		return fmt.Errorf("unexpected genesis app state type of %t", cfg.Genesis.AppState)
+	}
+
+	genesisState.Balances = append(genesisState.Balances, balances...)
+	cfg.Genesis.AppState = genesisState
+	return nil
+}
+
 // NewMockedPrivValidator generate a new key
 func NewMockedPrivValidator() bft.PrivValidator {
 	return bft.NewMockPVWithParams(ed25519.GenPrivKey(), false, false)

gno.land/pkg/sdk/vm/keeper.go

@@ -179,6 +179,7 @@ func (vm *VMKeeper) AddPackage(ctx sdk.Context, msg MsgAddPackage) error {
 		ChainID:       ctx.ChainID(),
 		Height:        ctx.BlockHeight(),
 		Timestamp:     ctx.BlockTime().Unix(),
+		TimestampNano: int64(ctx.BlockTime().Nanosecond()),
 		Msg:           msg,
 		OrigCaller:    creator.Bech32(),
 		OrigSend:      deposit,
@@ -257,6 +258,7 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 		ChainID:       ctx.ChainID(),
 		Height:        ctx.BlockHeight(),
 		Timestamp:     ctx.BlockTime().Unix(),
+		TimestampNano: int64(ctx.BlockTime().Nanosecond()),
 		Msg:           msg,
 		OrigCaller:    caller.Bech32(),
 		OrigSend:      send,
@@ -328,6 +330,7 @@ func (vm *VMKeeper) Run(ctx sdk.Context, msg MsgRun) (res string, err error) {
 		ChainID:       ctx.ChainID(),
 		Height:        ctx.BlockHeight(),
 		Timestamp:     ctx.BlockTime().Unix(),
+		TimestampNano: int64(ctx.BlockTime().Nanosecond()),
 		Msg:           msg,
 		OrigCaller:    caller.Bech32(),
 		OrigSend:      send,
@@ -457,9 +460,10 @@ func (vm *VMKeeper) QueryEval(ctx sdk.Context, pkgPath string, expr string) (res
 	}
 	// Construct new machine.
 	msgCtx := stdlibs.ExecContext{
-		ChainID:   ctx.ChainID(),
-		Height:    ctx.BlockHeight(),
-		Timestamp: ctx.BlockTime().Unix(),
+		ChainID:       ctx.ChainID(),
+		Height:        ctx.BlockHeight(),
+		Timestamp:     ctx.BlockTime().Unix(),
+		TimestampNano: int64(ctx.BlockTime().Nanosecond()),
 		// Msg:           msg,
 		// OrigCaller:    caller,
 		// OrigSend:      send,
@@ -517,9 +521,10 @@ func (vm *VMKeeper) QueryEvalString(ctx sdk.Context, pkgPath string, expr string
 	}
 	// Construct new machine.
 	msgCtx := stdlibs.ExecContext{
-		ChainID:   ctx.ChainID(),
-		Height:    ctx.BlockHeight(),
-		Timestamp: ctx.BlockTime().Unix(),
+		ChainID:       ctx.ChainID(),
+		Height:        ctx.BlockHeight(),
+		Timestamp:     ctx.BlockTime().Unix(),
+		TimestampNano: int64(ctx.BlockTime().Nanosecond()),
 		// Msg:           msg,
 		// OrigCaller:    caller,
 		// OrigSend:      jsend,

gnovm/stdlibs/std/context.go

@@ -9,8 +9,8 @@ import (
 type ExecContext struct {
 	ChainID       string
 	Height        int64
-	Timestamp     int64 // seconds
-	TimestampNano int64 // nanoseconds, only used for testing.
+	Timestamp     int64
+	TimestampNano int64
 	Msg           sdk.Msg
 	OrigCaller    crypto.Bech32Address
 	OrigPkgAddr   crypto.Bech32Address

gnovm/tests/imports.go

@@ -190,6 +190,7 @@ func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Wri
 							ctx.Timestamp += 1
 							ctx.TimestampNano -= int64(time.Second)
 						}
+
 						m.Context = ctx
 					},
 				)