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

proto/pocket/supplier/claim.proto

@@ -4,11 +4,13 @@ package pocket.supplier;
 option go_package = "github.com/pokt-network/poktroll/x/supplier/types";
 
 import "cosmos_proto/cosmos.proto";
+import "pocket/session/session.proto";
 
 // Claim is the serialized object stored on-chain for claims pending to be proven
 message Claim {
   string supplier_address = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; // the address of the supplier that submitted this claim
-  string session_id = 2; // session id from the SessionHeader
-  uint64 session_end_block_height = 3; // session end block height from the SessionHeader
-  bytes root_hash = 4; // smt.SMST#Root()
+  // The session header of the session that this claim is for.
+  session.SessionHeader session_header = 2;
+  // Root hash returned from smt.SMST#Root().
+  bytes root_hash = 3;
 }

proto/pocket/supplier/proof.proto

@@ -1,14 +1,16 @@
 syntax = "proto3";
 package pocket.supplier;
 
+import "cosmos_proto/cosmos.proto";
+import "pocket/session/session.proto";
+
 option go_package = "github.com/pokt-network/poktroll/x/supplier/types";
 
-// TODO_UPNEXT(@Olshansk): The structure below is the default (untouched) scaffolded type. Update
-// and productionize it for our use case.
 message Proof {
-  string index = 1;
-  string supplier_address = 2;
-  string session_id = 3;
-  string merkle_proof = 4;
+  string supplier_address = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  // The session header of the session that this claim is for.
+  session.SessionHeader session_header = 2;
+  // The serialized SMST proof from the `#ClosestProof()` method.
+  bytes closest_merkle_proof = 3;
 }
 

proto/pocket/supplier/query.proto

@@ -2,9 +2,10 @@ syntax = "proto3";
 
 package pocket.supplier;
 
+import "cosmos_proto/cosmos.proto";
+import "cosmos/base/query/v1beta1/pagination.proto";
 import "gogoproto/gogo.proto";
 import "google/api/annotations.proto";
-import "cosmos/base/query/v1beta1/pagination.proto";
 import "pocket/supplier/params.proto";
 import "pocket/shared/supplier.proto";
 import "pocket/supplier/claim.proto";
@@ -76,7 +77,7 @@ message QueryAllSupplierResponse {
 
 message QueryGetClaimRequest {
   string session_id = 1;
-  string supplier_address = 2;
+  string supplier_address = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
 }
 
 message QueryGetClaimResponse {

testutil/network/basenet/accounts.go

@@ -0,0 +1,194 @@
+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"
+	"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...)
+}
+
+// CreateOnChainAccounts creates on-chain accounts (i.e. auth module) for the sum of
+// the configured number of suppliers, applications, and gateways.
+func (memnet *BaseInMemoryNetwork) CreateOnChainAccounts(t *testing.T) {
+	t.Helper()
+
+	// NB: while it may initially seem like the memnet#Init<actor>AccountsWithSequence() 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.InitSupplierAccountsWithSequence(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.InitAppAccountsWithSequence(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.InitGatewayAccountsWithSequence(t, gatewayGenesisState.GatewayList...)
+	}
+
+	// need to wait for the account to be initialized in the next block
+	require.NoError(t, memnet.GetNetwork(t).WaitForNextBlock())
+}
+
+// InitAccount initializes an Account by sending it some funds from the validator
+// in the network to the address provided
+func (memnet *BaseInMemoryNetwork) InitAccount(
+	t *testing.T,
+	addr types.AccAddress,
+) {
+	t.Helper()
+
+	signerAccountNumber := 0
+	// Validator's client context MUST be used for this CLI command because its keyring includes the validator's key
+	clientCtx := memnet.Network.Validators[0].ClientCtx
+	// MUST NOT use memnet.GetClientCtx(t) as its keyring does not include the validator's account
+	// TODO_UPNEXT(@bryanchriswhite): Ensure validator key is always available via the in-memory network's keyring.
+	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.NextAccountSequenceNumber(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, types.NewCoins(types.NewCoin(net.Config.BondDenom, math.NewInt(10))).String()),
+	}
+	amount := types.NewCoins(types.NewCoin("stake", math.NewInt(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)
+}
+
+// GetPreGeneratedAccountIterator returns the pre-generated account iterator associated
+// with the in-memory network; i.e. used to populate genesis and the keyring. Calling
+// #Next() will return the next (unused) pre-generated account in the iterator.
+func (memnet *BaseInMemoryNetwork) CreateNewOnChainAccount(t *testing.T) *testkeyring.PreGeneratedAccount {
+	t.Helper()
+
+	preGeneratedAcct, ok := testkeyring.PreGeneratedAccounts().Next()
+	require.Truef(t, ok, "no pre-generated accounts available")
+
+	// Create a supplier on-chain account.
+	memnet.InitAccount(t, preGeneratedAcct.Address)
+
+	testkeyring.CreatePreGeneratedKeyringAccounts(t, memnet.GetClientCtx(t).Keyring, 1)
+
+	return preGeneratedAcct
+}
+
+// InitSupplierAccountsWithSequence uses the testCLI to create on-chain accounts
+// (i.e. auth module) for the addresses of the given suppliers.
+func (memnet *BaseInMemoryNetwork) InitSupplierAccountsWithSequence(
+	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.InitAccount(t, supplierAddr)
+	}
+}
+
+// InitAppAccountsWithSequence uses the testCLI to create on-chain accounts
+// (i.e. auth module) for the addresses of the given Applications.
+func (memnet *BaseInMemoryNetwork) InitAppAccountsWithSequence(
+	t *testing.T,
+	appList ...apptypes.Application,
+) {
+	t.Helper()
+
+	for _, application := range appList {
+		appAddr, err := types.AccAddressFromBech32(application.GetAddress())
+		require.NoError(t, err)
+		memnet.InitAccount(t, appAddr)
+	}
+}
+
+// InitGatewayAccountsWithSequence uses the testCLI to create on-chain accounts
+// (i.e. auth module) for the addresses of the given Gateways.
+func (memnet *BaseInMemoryNetwork) InitGatewayAccountsWithSequence(
+	t *testing.T,
+	gatewayList ...gatewaytypes.Gateway,
+) {
+	t.Helper()
+
+	for _, gateway := range gatewayList {
+		gatewayAddr, err := types.AccAddressFromBech32(gateway.GetAddress())
+		require.NoError(t, err)
+		memnet.InitAccount(t, gatewayAddr)
+	}
+}

testutil/network/basenet/network.go

@@ -0,0 +1,125 @@
+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 be embedded by other ("concrete") InMemoryNetwork implementations.
+type BaseInMemoryNetwork struct {
+	Config                      network.InMemoryNetworkConfig
+	PreGeneratedAccountIterator *testkeyring.PreGeneratedAccountIterator
+	Network                     *sdknetwork.Network
+
+	// lastAccountSeqNumber 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.
+	lastAccountSeqNumber 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 NextAccountSequenceNumber() (no boundary condition).
+		lastAccountSeqNumber: 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 not initialized, using default config")
+
+		// Initialize a network config.
+		cfg := network.DefaultConfig()
+		memnet.Config.CosmosCfg = &cfg
+	} else {
+		t.Log("Cosmos config already initialized, using existing config")
+	}
+}
+
+// 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_UPNEXT(@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.Network, "in-memory cosmos network not set")
+	return memnet.Network
+}
+
+// GetLastAccountSequenceNumber returns the last (most recently generated) account sequence number.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) GetLastAccountSequenceNumber(t *testing.T) int {
+	t.Helper()
+
+	return int(atomic.LoadInt32(&memnet.lastAccountSeqNumber))
+}
+
+// NextAccountSequenceNumber increments the account sequence number and returns the new value.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) NextAccountSequenceNumber(t *testing.T) int {
+	t.Helper()
+
+	return int(atomic.AddInt32(&memnet.lastAccountSeqNumber, 1))
+}
+
+// Start is a stub which is expected to be implemented by embedders. It panics when called.
+func (memnet *BaseInMemoryNetwork) Start(_ context.Context, t *testing.T) {
+	panic("not implemented")
+}