[Testing, Tooling] feat: implement in-memory networks

testutil/network/basenet/accounts.go

@@ -0,0 +1,200 @@
+package basenet
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"cosmossdk.io/math"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	testcli "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+
+	"github.com/pokt-network/poktroll/testutil/network"
+	"github.com/pokt-network/poktroll/testutil/testkeyring"
+	apptypes "github.com/pokt-network/poktroll/x/application/types"
+	gatewaytypes "github.com/pokt-network/poktroll/x/gateway/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+	suppliertypes "github.com/pokt-network/poktroll/x/supplier/types"
+)
+
+const warnNoModuleGenesisFmt = "WARN: no %s module genesis state found, if this is unexpected, ensure that genesis is populated before creating on-chain accounts"
+
+// CreateKeyringAccounts populates the Keyring associated with the in-memory
+// network with memnet.numKeyringAccounts() number of pre-generated accounts.
+func (memnet *BaseInMemoryNetwork) CreateKeyringAccounts(t *testing.T) {
+	t.Helper()
+
+	// Keyring MAY be provided setting InMemoryNetworkConfig#Keyring.
+	if memnet.Config.Keyring == nil {
+		t.Log("Keyring not initialized, using new in-memory keyring")
+
+		// Construct an in-memory keyring so that it can be populated and used prior
+		// to network start.
+		memnet.Config.Keyring = keyring.NewInMemory(memnet.Config.CosmosCfg.Codec)
+	} else {
+		t.Log("Keyring already initialized, using existing keyring")
+	}
+
+	// Create memnet.NumKeyringAccounts() number of accounts in the configured keyring.
+	accts := testkeyring.CreatePreGeneratedKeyringAccounts(
+		t, memnet.Config.Keyring, memnet.Config.GetNumKeyringAccounts(t),
+	)
+
+	// Assign the memnet's pre-generated accounts to a new pre-generated
+	// accounts iterator containing only the accounts which were also created
+	// in the keyring.
+	memnet.PreGeneratedAccountIterator = testkeyring.NewPreGeneratedAccountIterator(accts...)
+}
+
+// FundOnChainAccounts creates on-chain accounts (i.e. auth module) for the sum of
+// the configured number of suppliers, applications, and gateways.
+func (memnet *BaseInMemoryNetwork) FundOnChainAccounts(t *testing.T) {
+	t.Helper()
+
+	// NB: while it may initially seem like the memnet#Fund<actor>Accounts() methods
+	// can be refactored into a generic function, this is not possible so long as the genesis
+	// state lists are passed directly & remain a slice of concrete types (as opposed to pointers).
+	// Under these conditions, a generic function would not be able to unmarshal the genesis state
+	// stored in the in-memory network because it is unmarshalling uses reflection, and it is not
+	// possible to reflect over a nil generic type value.
+
+	// Retrieve the supplier module's genesis state from cosmos-sdk in-memory network.
+	supplierGenesisState := network.GetGenesisState[*suppliertypes.GenesisState](t, suppliertypes.ModuleName, memnet)
+	if supplierGenesisState == nil {
+		t.Logf(warnNoModuleGenesisFmt, "supplier")
+	} else {
+		// Initialize on-chain accounts for genesis suppliers.
+		memnet.FundSupplierAccounts(t, supplierGenesisState.SupplierList...)
+
+	}
+
+	// Retrieve the application module's genesis state from cosmos-sdk in-memory network.
+	appGenesisState := network.GetGenesisState[*apptypes.GenesisState](t, apptypes.ModuleName, memnet)
+	if appGenesisState == nil {
+		t.Logf(warnNoModuleGenesisFmt, "application")
+	} else {
+		// Initialize on-chain accounts for genesis applications.
+		memnet.FundAppAccounts(t, appGenesisState.ApplicationList...)
+	}
+
+	// Retrieve the gateway module's genesis state from cosmos-sdk in-memory network.
+	gatewayGenesisState := network.GetGenesisState[*gatewaytypes.GenesisState](t, gatewaytypes.ModuleName, memnet)
+	if gatewayGenesisState == nil {
+		t.Logf(warnNoModuleGenesisFmt, "gateway")
+	} else {
+		// Initialize on-chain accounts for genesis gateways.
+		memnet.FundGatewayAccounts(t, gatewayGenesisState.GatewayList...)
+	}
+
+	// need to wait for the account to be initialized in the next block
+	require.NoError(t, memnet.GetNetwork(t).WaitForNextBlock())
+}
+
+// FundAddress initializes an Account address and sequence number with the auth module
+// by sending some tokens from the in-memory network  validator, to the address provided.
+// This is a necessary prerequesite in order for the account with the given address
+// to be able to submit valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundAddress(
+	t *testing.T,
+	addr types.AccAddress,
+) {
+	t.Helper()
+
+	signerAccountNumber := 0
+	clientCtx := memnet.GetClientCtx(t)
+	net := memnet.GetNetwork(t)
+	val := net.Validators[0]
+
+	args := []string{
+		fmt.Sprintf("--%s=true", flags.FlagOffline),
+		fmt.Sprintf("--%s=%d", flags.FlagAccountNumber, signerAccountNumber),
+		fmt.Sprintf("--%s=%d", flags.FlagSequence, memnet.NextValidatorTxSequenceNumber(t)),
+
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, memnet.NewBondDenomCoins(t, 10).String()),
+	}
+	amount := memnet.NewBondDenomCoins(t, 200)
+	responseRaw, err := testcli.MsgSendExec(clientCtx, val.Address, addr, amount, args...)
+	require.NoError(t, err)
+	var responseJSON map[string]interface{}
+	err = json.Unmarshal(responseRaw.Bytes(), &responseJSON)
+	require.NoError(t, err)
+	require.Equal(t, float64(0), responseJSON["code"], "code is not 0 in the response: %v", responseJSON)
+}
+
+// FundSupplierAccounts initializes account addresses and sequence numbers for,
+// each supplier in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundSupplierAccounts(
+	t *testing.T,
+	supplierList ...sharedtypes.Supplier,
+) {
+	t.Helper()
+
+	net := memnet.GetNetwork(t)
+	require.NotNil(t, net, "in-memory cosmos testutil network not initialized yet, call #Start() first")
+
+	for _, supplier := range supplierList {
+		supplierAddr, err := types.AccAddressFromBech32(supplier.GetAddress())
+		require.NoError(t, err)
+		memnet.FundAddress(t, supplierAddr)
+	}
+}
+
+// FundAppAccounts initializes account addresses and sequence numbers for, each
+// application in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundAppAccounts(
+	t *testing.T,
+	appList ...apptypes.Application,
+) {
+	t.Helper()
+
+	for _, application := range appList {
+		appAddr, err := types.AccAddressFromBech32(application.GetAddress())
+		require.NoError(t, err)
+		memnet.FundAddress(t, appAddr)
+	}
+}
+
+// FundGatewayAccounts initializes account addresses and sequence numbers for, each
+// gateway in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundGatewayAccounts(
+	t *testing.T,
+	gatewayList ...gatewaytypes.Gateway,
+) {
+	t.Helper()
+
+	for _, gateway := range gatewayList {
+		gatewayAddr, err := types.AccAddressFromBech32(gateway.GetAddress())
+		require.NoError(t, err)
+		memnet.FundAddress(t, gatewayAddr)
+	}
+}
+
+func (memnet *BaseInMemoryNetwork) NewBondDenomCoins(t *testing.T, numCoins int64) sdk.Coins {
+	t.Helper()
+
+	return sdk.NewCoins(sdk.NewCoin(memnet.GetNetwork(t).Config.BondDenom, math.NewInt(numCoins)))
+}

testutil/network/basenet/network.go

@@ -0,0 +1,130 @@
+package basenet
+
+import (
+	"context"
+	"sync/atomic"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	sdknetwork "github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/stretchr/testify/require"
+
+	"github.com/pokt-network/poktroll/testutil/network"
+	"github.com/pokt-network/poktroll/testutil/testkeyring"
+)
+
+var _ network.InMemoryNetwork = (*BaseInMemoryNetwork)(nil)
+
+// BaseInMemoryNetwork is an "abstract" (i.e. partial) implementation, intended
+// to consolidate shared behavior between multiple ("concrete") InMemoryNetwork
+// implementations. These shared behaviors (methods) are accessible to any concrete
+// implementation which embeds BaseInMemoryNetwork.
+type BaseInMemoryNetwork struct {
+	Config                      network.InMemoryNetworkConfig
+	PreGeneratedAccountIterator *testkeyring.PreGeneratedAccountIterator
+	CosmosNetwork               *sdknetwork.Network
+
+	// lastValidatorSeqNumber stores the last (most recently generated) account sequence number.
+	// NB: explicitly NOT using atomic.Int32 as it's usage doesn't compose well with anonymous
+	// literal declarations.
+	lastValidatorSeqNumber int32
+}
+
+// NewBaseInMemoryNetwork creates a new BaseInMemoryNetwork with the given
+// configuration and pre-generated accounts. Intended to be used in constructor
+// functions of structs that embed BaseInMemoryNetwork.
+func NewBaseInMemoryNetwork(
+	t *testing.T,
+	cfg *network.InMemoryNetworkConfig,
+	preGeneratedAccounts *testkeyring.PreGeneratedAccountIterator,
+) *BaseInMemoryNetwork {
+	t.Helper()
+
+	return &BaseInMemoryNetwork{
+		Config:                      *cfg,
+		PreGeneratedAccountIterator: preGeneratedAccounts,
+
+		// First functional account sequence number is 1. Starting at 0 so that
+		// callers can always use NextValidatorTxSequenceNumber() (no boundary condition).
+		lastValidatorSeqNumber: int32(0),
+	}
+}
+
+// InitializeDefaults sets the underlying cosmos-sdk testutil network config to
+// a reasonable default in case one was not provided with the InMemoryNetworkConfig.
+func (memnet *BaseInMemoryNetwork) InitializeDefaults(t *testing.T) {
+	if memnet.Config.CosmosCfg != nil {
+		t.Log("Cosmos config already initialized, using existing config")
+		return
+	}
+
+	t.Log("Cosmos config not initialized, using default config")
+	// Initialize a network config.
+	cfg := network.DefaultConfig()
+	memnet.Config.CosmosCfg = &cfg
+}
+
+// GetClientCtx returns the underlying cosmos-sdk testutil network's client context.
+func (memnet *BaseInMemoryNetwork) GetClientCtx(t *testing.T) client.Context {
+	t.Helper()
+
+	// Only the first validator's client context is populated.
+	// (see: https://pkg.go.dev/github.com/cosmos/cosmos-sdk/testutil/network#pkg-overview)
+	ctx := memnet.GetNetwork(t).Validators[0].ClientCtx
+
+	// TODO_NEXT(@bryanchriswhite): Ensure validator key is always available.
+
+	// Overwrite the client context's Keyring with the in-memory one that contains
+	// our pre-generated accounts.
+	return ctx.WithKeyring(memnet.Config.Keyring)
+}
+
+// GetConfig returns the InMemoryNetworkConfig which associated with a given
+// InMemoryNetwork instance.
+func (memnet *BaseInMemoryNetwork) GetConfig(t *testing.T) *network.InMemoryNetworkConfig {
+	t.Helper()
+
+	return &memnet.Config
+}
+
+// GetCosmosNetworkConfig returns the underlying cosmos-sdk testutil network config.
+// It requires that the config has been set, failing the test if not.
+func (memnet *BaseInMemoryNetwork) GetCosmosNetworkConfig(t *testing.T) *sdknetwork.Config {
+	t.Helper()
+
+	require.NotEmptyf(t, memnet.Config, "in-memory network config not set")
+	return memnet.Config.CosmosCfg
+}
+
+// GetNetwork returns the underlying cosmos-sdk testutil network instance.
+// It requires that the cosmos-sdk in-memory network has been set, failing the test if not.
+func (memnet *BaseInMemoryNetwork) GetNetwork(t *testing.T) *sdknetwork.Network {
+	t.Helper()
+
+	require.NotEmptyf(t, memnet.CosmosNetwork, "in-memory cosmos network not set")
+	return memnet.CosmosNetwork
+}
+
+// GetLastValidatorTxSequenceNumber returns the last (most recently generated) account sequence number.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) GetLastValidatorTxSequenceNumber(t *testing.T) int {
+	t.Helper()
+
+	return int(atomic.LoadInt32(&memnet.lastValidatorSeqNumber))
+}
+
+// NextValidatorTxSequenceNumber increments the account sequence number and returns the new value.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) NextValidatorTxSequenceNumber(t *testing.T) int {
+	t.Helper()
+
+	return int(atomic.AddInt32(&memnet.lastValidatorSeqNumber, 1))
+}
+
+// Start is a stub which is expected to be implemented by "concrete" InMemoryNetwork
+// implementations. As BaseInMemoryNetwork is intended to be an "abstract" implementation,
+// it is too general to define this behavior, leaving it up to embedders. As a result,
+// this function panics if it is called.
+func (memnet *BaseInMemoryNetwork) Start(_ context.Context, t *testing.T) {
+	panic("must be implemented by struct embedders")
+}