feat(SPV-1592): create engine.V2

Author: dorzepowski

engine/v2/database/testabilities/fixture_database.go

@@ -45,7 +45,7 @@ type databaseFixture struct {
 func Given(t testing.TB, opts ...testengine.ConfigOpts) (given DatabaseFixture, cleanup func()) {
 	engineWithConfig, cleanup := testengine.Given(t).EngineWithConfiguration(opts...)
 
-	db := engineWithConfig.Engine.Datastore().DB()
+	db := engineWithConfig.Engine.DB()
 	fixture := &databaseFixture{
 		t:  t,
 		db: db,

engine/v2/engine/engine.go

@@ -0,0 +1,244 @@
+package engine
+
+import (
+	"context"
+	"errors"
+
+	"github.com/bitcoin-sv/go-paymail/server"
+	"github.com/bitcoin-sv/spv-wallet/config"
+	"github.com/bitcoin-sv/spv-wallet/engine/chain"
+	"github.com/bitcoin-sv/spv-wallet/engine/chain/models"
+	"github.com/bitcoin-sv/spv-wallet/engine/paymail"
+	"github.com/bitcoin-sv/spv-wallet/engine/spverrors"
+	"github.com/bitcoin-sv/spv-wallet/engine/utils"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/addresses"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/data"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/database/repository"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/engine/internal"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/fee"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/operations"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/paymails"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/paymailserver"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/transaction/beef"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/transaction/outlines"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/transaction/record"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/transaction/txsync"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/users"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/utils/must"
+	"github.com/go-resty/resty/v2"
+	"github.com/rs/zerolog"
+	"gorm.io/gorm"
+)
+
+type V2 struct {
+	cfg     *config.AppConfig
+	storage *internal.Storage
+
+	repositories *repository.All
+
+	chainService chain.Service
+
+	usersService               *users.Service
+	paymailsService            *paymails.Service
+	addressesService           *addresses.Service
+	dataService                *data.Service
+	operationsService          *operations.Service
+	transactionsOutlineService outlines.Service
+	transactionsRecordService  *record.Service
+	txSyncService              *txsync.Service
+	paymailServerConfig        *server.Configuration
+}
+
+func NewEngine(cfg *config.AppConfig, logger zerolog.Logger, overridesOpts ...InternalsOverride) *V2 {
+	logger = logger.With().Int("v", 2).Str("service", "engine").Logger()
+
+	overridesToApply := &overrides{}
+	for _, opt := range overridesOpts {
+		opt(overridesToApply)
+	}
+
+	// Database
+	storage := internal.NewStorage(cfg, logger)
+	err := storage.Start()
+	must.HaveNoErrorf(err, "failed to start wallet storage")
+
+	repos := storage.CreateRepositories()
+
+	// Low level services
+	var httpClient *resty.Client
+	if overridesToApply.resty != nil {
+		httpClient = overridesToApply.resty
+	} else {
+		httpClient = resty.New()
+		if overridesToApply.transport != nil {
+			httpClient.SetTransport(overridesToApply.transport)
+		}
+	}
+
+	paymailClient := setupPaymailClient(overridesToApply, httpClient)
+
+	cache := internal.NewCache(cfg, logger)
+
+	chainService := chain.NewChainService(logger, httpClient, extractARCConfig(cfg), extractBHSConfig(cfg))
+	feeService := fee.NewService(cfg, chainService, logger)
+
+	// TODO: use feeService instead of fee unit in services
+	feeUnit, err := feeService.GetFeeUnit(context.Background())
+	must.HaveNoErrorf(err, "failed to setup fee unit")
+
+	paymailServiceClient := paymail.NewServiceClient(cache, paymailClient, logger)
+
+	utxoSelector := storage.CreateUTXOSelector(feeService)
+
+	beefService := beef.NewService(repos.Transactions)
+
+	userService := users.NewService(repos.Users, cfg)
+	paymailService := paymails.NewService(repos.Paymails, userService, cfg)
+	addressesService := addresses.NewService(repos.Addresses)
+	dataService := data.NewService(repos.Data)
+	operationsService := operations.NewService(repos.Operations)
+	txSyncService := txsync.NewService(logger, repos.Transactions)
+
+	transactionsOutlineService := outlines.NewService(
+		paymailServiceClient,
+		paymailService,
+		beefService,
+		utxoSelector,
+		feeUnit,
+		logger,
+		userService,
+	)
+
+	transactionsRecordService := record.NewService(
+		logger,
+		addressesService,
+		userService,
+		repos.Outputs,
+		repos.Operations,
+		repos.Transactions,
+		chainService,
+		paymailServiceClient,
+	)
+
+	paymailServiceProvider := paymailserver.NewServiceProvider(
+		logger,
+		paymailService,
+		userService,
+		addressesService,
+		chainService,
+		transactionsRecordService,
+	)
+
+	paymailServerConfig := setupPaymailServer(cfg, logger, paymailServiceProvider)
+
+	return &V2{
+		cfg:                        cfg,
+		storage:                    storage,
+		repositories:               repos,
+		chainService:               chainService,
+		usersService:               userService,
+		paymailsService:            paymailService,
+		addressesService:           addressesService,
+		dataService:                dataService,
+		operationsService:          operationsService,
+		transactionsOutlineService: transactionsOutlineService,
+		transactionsRecordService:  transactionsRecordService,
+		txSyncService:              txSyncService,
+		paymailServerConfig:        paymailServerConfig,
+	}
+}
+
+// Close closes the V2 and all its services
+func (e *V2) Close(_ context.Context) error {
+	var allErrors error
+	err := e.storage.Close()
+	if err != nil {
+		allErrors = errors.Join(allErrors, spverrors.Wrapf(err, "couldn't close storage"))
+	}
+	return allErrors
+}
+
+// Deprecated: used as adapter for engine v1
+func (e *V2) DB() *gorm.DB {
+	return e.storage.DB()
+}
+
+func (e *V2) Repositories() *repository.All {
+	return e.repositories
+}
+
+func (e *V2) Chain() chain.Service {
+	return e.chainService
+}
+
+func (e *V2) UsersService() *users.Service {
+	return e.usersService
+}
+
+func (e *V2) PaymailsService() *paymails.Service {
+	return e.paymailsService
+}
+
+func (e *V2) AddressesService() *addresses.Service {
+	return e.addressesService
+}
+
+func (e *V2) DataService() *data.Service {
+	return e.dataService
+}
+
+func (e *V2) OperationsService() *operations.Service {
+	return e.operationsService
+}
+
+func (e *V2) TransactionOutlinesService() outlines.Service {
+	return e.transactionsOutlineService
+}
+
+func (e *V2) TransactionRecordService() *record.Service {
+	return e.transactionsRecordService
+}
+
+func (e *V2) TxSyncService() *txsync.Service {
+	return e.txSyncService
+}
+
+func (e *V2) PaymailServerConfiguration() *server.Configuration {
+	return e.paymailServerConfig
+}
+
+func extractBHSConfig(cfg *config.AppConfig) chainmodels.BHSConfig {
+	return chainmodels.BHSConfig{
+		URL:       cfg.BHS.URL,
+		AuthToken: cfg.BHS.AuthToken,
+	}
+}
+
+func extractARCConfig(cfg *config.AppConfig) chainmodels.ARCConfig {
+	arcCfg := chainmodels.ARCConfig{
+		URL:          cfg.ARC.URL,
+		Token:        cfg.ARC.Token,
+		DeploymentID: cfg.ARC.DeploymentID,
+		WaitFor:      cfg.ARC.WaitForStatus,
+	}
+
+	if cfg.ARC.Callback.Enabled {
+		var err error
+		if cfg.ARC.Callback.Token == "" {
+			// This also sets the token to the config reference and, it is used in the callbacktoken_middleware
+			// TODO: consider moving config modification to a PostLoad method and make this ToEngineOptions pure (no side effects)
+			cfg.ARC.Callback.Token, err = utils.HashAdler32(config.DefaultAdminXpub)
+			must.HaveNoErrorf(err, "error while generating callback token")
+		}
+		arcCfg.Callback = &chainmodels.ARCCallbackConfig{
+			URL:   cfg.ARC.Callback.Host + config.BroadcastCallbackRoute,
+			Token: cfg.ARC.Callback.Token,
+		}
+	}
+
+	if cfg.ExperimentalFeatures != nil && cfg.ExperimentalFeatures.UseJunglebus {
+		arcCfg.UseJunglebus = true
+	}
+
+	return arcCfg
+}

engine/v2/engine/engine_overrides.go

@@ -0,0 +1,42 @@
+package engine
+
+import (
+	"net/http"
+
+	"github.com/bitcoin-sv/spv-wallet/engine/paymail"
+	"github.com/go-resty/resty/v2"
+)
+
+// InternalsOverride is a function that can be used to override internal dependencies.
+// This is meant to be used for testing purposes.
+type InternalsOverride = func(*overrides)
+
+type overrides struct {
+	transport     http.RoundTripper
+	resty         *resty.Client
+	paymailClient paymail.ClientInterface
+}
+
+// WithResty is a function that can be used to override the resty.Client used by the engine.
+// This is meant to be used for testing purposes.
+func WithResty(resty *resty.Client) InternalsOverride {
+	return func(o *overrides) {
+		o.resty = resty
+	}
+}
+
+// WithTransport is a function that can be used to override the http.RoundTripper used by the engine.
+// This is meant to be used for testing purposes.
+func WithTransport(transport http.RoundTripper) InternalsOverride {
+	return func(o *overrides) {
+		o.transport = transport
+	}
+}
+
+// WithPaymailClient is a function that can be used to override the paymail.ClientInterface used by the engine.
+// This is meant to be used for testing purposes.
+func WithPaymailClient(client paymail.ClientInterface) InternalsOverride {
+	return func(o *overrides) {
+		o.paymailClient = client
+	}
+}

engine/v2/engine/internal/cache.go

@@ -0,0 +1,64 @@
+package internal
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/bitcoin-sv/spv-wallet/config"
+	"github.com/bitcoin-sv/spv-wallet/engine/logging"
+	"github.com/bitcoin-sv/spv-wallet/engine/v2/utils/must"
+	"github.com/mrz1836/go-cachestore"
+	"github.com/rs/zerolog"
+)
+
+type Cache interface {
+	GetModel(ctx context.Context, key string, model interface{}) error
+	SetModel(ctx context.Context, key string, model interface{}, ttl time.Duration, dependencies ...string) error
+}
+
+type cacheOptions struct {
+	opts []cachestore.ClientOps
+}
+
+func (o *cacheOptions) configureLogger(cfg *config.AppConfig, logger zerolog.Logger) *cacheOptions {
+	cachestoreLogger := logging.CreateGormLoggerAdapter(&logger, "cachestore")
+	o.opts = append(o.opts, cachestore.WithLogger(cachestoreLogger))
+	if logger.GetLevel() == zerolog.DebugLevel || logger.GetLevel() == zerolog.TraceLevel {
+		o.opts = append(o.opts, cachestore.WithDebugging())
+	}
+	return o
+}
+
+func (o *cacheOptions) configureEngine(cfg *config.AppConfig) *cacheOptions {
+	if cfg.Cache.Engine == cachestore.Redis {
+		o.opts = append(o.opts, cachestore.WithRedis(&cachestore.RedisConfig{
+			DependencyMode:        cfg.Cache.Redis.DependencyMode,
+			MaxActiveConnections:  cfg.Cache.Redis.MaxActiveConnections,
+			MaxConnectionLifetime: cfg.Cache.Redis.MaxConnectionLifetime,
+			MaxIdleConnections:    cfg.Cache.Redis.MaxIdleConnections,
+			MaxIdleTimeout:        cfg.Cache.Redis.MaxIdleTimeout,
+			URL:                   cfg.Cache.Redis.URL,
+			UseTLS:                cfg.Cache.Redis.UseTLS,
+		}))
+	} else if cfg.Cache.Engine == cachestore.FreeCache {
+		o.opts = append(o.opts, cachestore.WithFreeCache())
+	} else {
+		panic(fmt.Sprintf("invalid configuration: unsupported cache engine: %s", cfg.Cache.Engine))
+	}
+
+	return o
+}
+
+func NewCache(cfg *config.AppConfig, logger zerolog.Logger) Cache {
+	logger.With().Str("service", "cache").Logger()
+
+	options := cacheOptions{make([]cachestore.ClientOps, 0)}
+
+	options.configureLogger(cfg, logger).configureEngine(cfg)
+
+	cache, err := cachestore.NewClient(context.Background(), options.opts...)
+	must.HaveNoErrorf(err, "failed to create cache storage: %v", err)
+
+	return cache
+}