refactor/internal (#1216)

* refactor: update import paths in gateway handlers

* refactor: remove obsolete devtools Makefile and README

* build: optimize build process for improved efficiency

* refactor: remove obsolete pkl files related to Matrix and Sonr network configurations

* refactor: move embed code to x/dwn/types

internal/chain/README.md

@@ -0,0 +1 @@
+# Core

internal/chain/appmodule/environment.go

@@ -0,0 +1,30 @@
+package appmodule
+
+import (
+	"cosmossdk.io/core/event"
+	"cosmossdk.io/core/gas"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/core/store"
+
+	"github.com/onsonr/sonr/internal/chain/branch"
+	"github.com/onsonr/sonr/internal/chain/log"
+	"github.com/onsonr/sonr/internal/chain/router"
+	"github.com/onsonr/sonr/internal/chain/transaction"
+)
+
+// Environment is used to get all services to their respective module.
+// Contract: All fields of environment are always populated by runtime.
+type Environment struct {
+	Logger log.Logger
+
+	BranchService      branch.Service
+	EventService       event.Service
+	GasService         gas.Service
+	HeaderService      header.Service
+	QueryRouterService router.Service
+	MsgRouterService   router.Service
+	TransactionService transaction.Service
+
+	KVStoreService  store.KVStoreService
+	MemStoreService store.MemoryStoreService
+}

internal/chain/branch/branch.go

@@ -0,0 +1,34 @@
+// Package branch contains the core branch service interface.
+package branch
+
+import (
+	"context"
+	"errors"
+)
+
+// ErrGasLimitExceeded is returned when the gas limit is exceeded in a
+// Service.ExecuteWithGasLimit call.
+var ErrGasLimitExceeded = errors.New("branch: gas limit exceeded")
+
+// Service is the branch service interface. It can be used to execute
+// code paths in an isolated execution context that can be reverted.
+// A revert typically means a rollback on events and state changes.
+type Service interface {
+	// Execute executes the given function in an isolated context. If the
+	// `f` function returns an error, the execution is considered failed,
+	// and every change made affecting the execution context is rolled back.
+	// If the function returns nil, the execution is considered successful, and
+	// committed.
+	// The context.Context passed to the `f` function is a child of the context
+	// passed to the Execute function, and is what should be used with other
+	// core services in order to ensure the execution remains isolated.
+	Execute(ctx context.Context, f func(ctx context.Context) error) error
+	// ExecuteWithGasLimit executes the given function `f` in an isolated context,
+	// with the provided gas limit, this is advanced usage and is used to disallow
+	// an execution path to consume an indefinite amount of gas.
+	// If the execution fails or succeeds the gas limit is still applied to the
+	// parent context, the function returns a gasUsed value which is the amount
+	// of gas used by the execution path. If the execution path exceeds the gas
+	// ErrGasLimitExceeded is returned.
+	ExecuteWithGasLimit(ctx context.Context, gasLimit uint64, f func(ctx context.Context) error) (gasUsed uint64, err error)
+}

internal/chain/log/logger.go

@@ -0,0 +1,29 @@
+package log
+
+const ModuleKey = "module"
+
+// Logger defines basic logger functionality that all previous versions of the Logger interface should
+// support. Library users should prefer to use this interface when possible, then type case to Logger
+// to see if WithContext is supported.
+type Logger interface {
+	// Info takes a message and a set of key/value pairs and logs with level INFO.
+	// The key of the tuple must be a string.
+	Info(msg string, keyVals ...any)
+
+	// Warn takes a message and a set of key/value pairs and logs with level WARN.
+	// The key of the tuple must be a string.
+	Warn(msg string, keyVals ...any)
+
+	// Error takes a message and a set of key/value pairs and logs with level ERR.
+	// The key of the tuple must be a string.
+	Error(msg string, keyVals ...any)
+
+	// Debug takes a message and a set of key/value pairs and logs with level DEBUG.
+	// The key of the tuple must be a string.
+	Debug(msg string, keyVals ...any)
+
+	// Impl returns the underlying logger implementation.
+	// It is used to access the full functionalities of the underlying logger.
+	// Advanced users can type cast the returned value to the actual logger.
+	Impl() any
+}

internal/chain/router/service.go

@@ -0,0 +1,16 @@
+package router
+
+import (
+	"context"
+
+	"github.com/onsonr/sonr/internal/chain/transaction"
+)
+
+// Service is the interface that wraps the basic methods for a router.
+// A router can be a query router or a message router.
+type Service interface {
+	// CanInvoke returns an error if the given request cannot be invoked.
+	CanInvoke(ctx context.Context, typeURL string) error
+	// Invoke execute a message or query. The response should be type casted by the caller to the expected response.
+	Invoke(ctx context.Context, req transaction.Msg) (res transaction.Msg, err error)
+}

internal/chain/transaction/service.go

@@ -0,0 +1,25 @@
+package transaction
+
+import "context"
+
+// ExecMode defines the execution mode
+type ExecMode uint8
+
+// All possible execution modes.
+// For backwards compatibility and easier casting, the exec mode values must be the same as in cosmos/cosmos-sdk/types package.
+const (
+	ExecModeCheck ExecMode = iota
+	ExecModeReCheck
+	ExecModeSimulate
+	_
+	_
+	_
+	_
+	ExecModeFinalize
+)
+
+// Service creates a transaction service.
+type Service interface {
+	// ExecMode returns the current execution mode.
+	ExecMode(ctx context.Context) ExecMode
+}

internal/chain/transaction/transaction.go

@@ -0,0 +1,45 @@
+package transaction
+
+type (
+	// Msg uses structural types to define the interface for a message.
+	Msg = interface {
+		Reset()
+		String() string
+		ProtoMessage()
+	}
+	Identity = []byte
+)
+
+// GenericMsg defines a generic version of a Msg.
+// The GenericMsg refers to the non pointer version of Msg,
+// and is required to allow its instantiations in generic contexts.
+type GenericMsg[T any] interface {
+	*T
+	Msg
+}
+
+// Codec defines the TX codec, which converts a TX from bytes to its concrete representation.
+type Codec[T Tx] interface {
+	// Decode decodes the tx bytes into a DecodedTx, containing
+	// both concrete and bytes representation of the tx.
+	Decode([]byte) (T, error)
+	// DecodeJSON decodes the tx JSON bytes into a DecodedTx
+	DecodeJSON([]byte) (T, error)
+}
+
+// Tx defines the interface for a transaction.
+// All custom transactions must implement this interface.
+type Tx interface {
+	// Hash returns the unique identifier for the Tx.
+	Hash() [32]byte
+	// GetMessages returns the list of state transitions of the Tx.
+	GetMessages() ([]Msg, error)
+	// GetSenders returns the tx state transition sender.
+	GetSenders() ([]Identity, error) // TODO reduce this to a single identity if accepted
+	// GetGasLimit returns the gas limit of the tx. Must return math.MaxUint64 for infinite gas
+	// txs.
+	GetGasLimit() (uint64, error)
+	// Bytes returns the encoded version of this tx. Note: this is ideally cached
+	// from the first instance of the decoding of the tx.
+	Bytes() []byte
+}