Replace Horizon calls with RPC

.gitignore

@@ -3,4 +3,6 @@
 captive-core*/
 .env
 .DS_Store
-env.sh
+env.sh
+.idea
+__debug_bin*

cmd/channel_account.go

@@ -2,14 +2,12 @@ package cmd
 
 import (
 	"fmt"
-	"net/http"
 	"strconv"
-	"time"
 
 	"github.com/spf13/cobra"
-	"github.com/stellar/go/clients/horizonclient"
 	"github.com/stellar/go/support/config"
 	"github.com/stellar/go/support/log"
+
 	"github.com/stellar/wallet-backend/cmd/utils"
 	"github.com/stellar/wallet-backend/internal/db"
 	"github.com/stellar/wallet-backend/internal/services"
@@ -19,7 +17,6 @@ import (
 
 type channelAccountCmdConfigOptions struct {
 	DatabaseURL                   string
-	HorizonClientURL              string
 	NetworkPassphrase             string
 	BaseFee                       int
 	DistributionAccountPrivateKey string
@@ -36,7 +33,6 @@ func (c *channelAccountCmd) Command() *cobra.Command {
 		utils.DatabaseURLOption(&cfg.DatabaseURL),
 		utils.NetworkPassphraseOption(&cfg.NetworkPassphrase),
 		utils.BaseFeeOption(&cfg.BaseFee),
-		utils.HorizonClientURLOption(&cfg.HorizonClientURL),
 		utils.ChannelAccountEncryptionPassphraseOption(&cfg.EncryptionPassphrase),
 	}
 
@@ -78,11 +74,7 @@ func (c *channelAccountCmd) Command() *cobra.Command {
 			channelAccountModel := store.ChannelAccountModel{DB: dbConnectionPool}
 			privateKeyEncrypter := signingutils.DefaultPrivateKeyEncrypter{}
 			c.channelAccountService, err = services.NewChannelAccountService(services.ChannelAccountServiceOptions{
-				DB: dbConnectionPool,
-				HorizonClient: &horizonclient.Client{
-					HorizonURL: cfg.HorizonClientURL,
-					HTTP:       &http.Client{Timeout: 40 * time.Second},
-				},
+				DB:                                 dbConnectionPool,
 				BaseFee:                            int64(cfg.BaseFee),
 				DistributionAccountSignatureClient: signatureClient,
 				ChannelAccountStore:                &channelAccountModel,

cmd/serve.go

@@ -8,6 +8,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/stellar/go/support/config"
 	"github.com/stellar/go/support/log"
+
 	"github.com/stellar/wallet-backend/cmd/utils"
 	"github.com/stellar/wallet-backend/internal/apptracker/sentry"
 	"github.com/stellar/wallet-backend/internal/db"
@@ -28,7 +29,6 @@ func (c *serveCmd) Command() *cobra.Command {
 		utils.LogLevelOption(&cfg.LogLevel),
 		utils.NetworkPassphraseOption(&cfg.NetworkPassphrase),
 		utils.BaseFeeOption(&cfg.BaseFee),
-		utils.HorizonClientURLOption(&cfg.HorizonClientURL),
 		utils.RPCURLOption(&cfg.RPCURL),
 		utils.RPCCallerChannelBufferSizeOption(&cfg.RPCCallerServiceChannelBufferSize),
 		utils.RPCCallerChannelMaxWorkersOption(&cfg.RPCCallerServiceChannelMaxWorkers),

cmd/utils/global_options.go

@@ -4,10 +4,10 @@ import (
 	"go/types"
 
 	"github.com/sirupsen/logrus"
-	"github.com/stellar/go/clients/horizonclient"
 	"github.com/stellar/go/network"
 	"github.com/stellar/go/support/config"
 	"github.com/stellar/go/txnbuild"
+
 	"github.com/stellar/wallet-backend/internal/signing"
 )
 
@@ -56,17 +56,6 @@ func BaseFeeOption(configKey *int) *config.ConfigOption {
 	}
 }
 
-func HorizonClientURLOption(configKey *string) *config.ConfigOption {
-	return &config.ConfigOption{
-		Name:        "horizon-url",
-		Usage:       "The URL of the Stellar Horizon server which this application will communicate with.",
-		OptType:     types.String,
-		ConfigKey:   configKey,
-		FlagDefault: horizonclient.DefaultTestNetClient.HorizonURL,
-		Required:    true,
-	}
-}
-
 func RPCURLOption(configKey *string) *config.ConfigOption {
 	return &config.ConfigOption{
 		Name:        "rpc-url",

go.mod

@@ -44,7 +44,6 @@ require (
 	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/magiconair/properties v1.8.7 // indirect
-	github.com/manucorporat/sse v0.0.0-20160126180136-ee05b128a739 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect

internal/entities/rpc.go

@@ -77,6 +77,19 @@ type RPCSendTransactionResult struct {
 	ErrorResultXDR        string    `json:"errorResultXdr"`
 }
 
+type LedgerEntryResult struct {
+	KeyXDR             string `json:"key,omitempty"`
+	DataXDR            string `json:"xdr,omitempty"`
+	LastModifiedLedger uint32 `json:"lastModifiedLedgerSeq"`
+	// The ledger sequence until the entry is live, available for entries that have associated ttl ledger entries.
+	LiveUntilLedgerSeq *uint32 `json:"liveUntilLedgerSeq,omitempty"`
+}
+
+type RPCGetLedgerEntriesResult struct {
+	LatestLedger uint32              `json:"latestLedger"`
+	Entries      []LedgerEntryResult `json:"entries"`
+}
+
 type RPCPagination struct {
 	Cursor string `json:"cursor,omitempty"`
 	Limit  int    `json:"limit"`
@@ -87,4 +100,5 @@ type RPCParams struct {
 	Hash        string        `json:"hash,omitempty"`
 	StartLedger int64         `json:"startLedger,omitempty"`
 	Pagination  RPCPagination `json:"pagination,omitempty"`
+	LedgerKeys  []string      `json:"keys,omitempty"`
 }

internal/serve/serve.go

@@ -8,11 +8,11 @@ import (
 
 	"github.com/go-chi/chi"
 	"github.com/sirupsen/logrus"
-	"github.com/stellar/go/clients/horizonclient"
 	supporthttp "github.com/stellar/go/support/http"
 	"github.com/stellar/go/support/log"
 	"github.com/stellar/go/support/render/health"
 	"github.com/stellar/go/xdr"
+
 	"github.com/stellar/wallet-backend/internal/apptracker"
 	"github.com/stellar/wallet-backend/internal/data"
 	"github.com/stellar/wallet-backend/internal/db"
@@ -60,7 +60,6 @@ type Configs struct {
 	NetworkPassphrase                  string
 	MaxSponsoredBaseReserves           int
 	BaseFee                            int
-	HorizonClientURL                   string
 	DistributionAccountSignatureClient signing.SignatureClient
 	ChannelAccountSignatureClient      signing.SignatureClient
 	// TSS
@@ -150,9 +149,10 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 		return handlerDeps{}, fmt.Errorf("instantiating stellar signature verifier: %w", err)
 	}
 
-	horizonClient := horizonclient.Client{
-		HorizonURL: cfg.HorizonClientURL,
-		HTTP:       &http.Client{Timeout: 40 * time.Second},
+	httpClient := http.Client{Timeout: time.Duration(30 * time.Second)}
+	rpcService, err := services.NewRPCService(cfg.RPCURL, &httpClient)
+	if err != nil {
+		return handlerDeps{}, fmt.Errorf("instantiating rpc service: %w", err)
 	}
 
 	accountService, err := services.NewAccountService(models)
@@ -163,7 +163,7 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 	accountSponsorshipService, err := services.NewAccountSponsorshipService(services.AccountSponsorshipServiceOptions{
 		DistributionAccountSignatureClient: cfg.DistributionAccountSignatureClient,
 		ChannelAccountSignatureClient:      cfg.ChannelAccountSignatureClient,
-		HorizonClient:                      &horizonClient,
+		RPCService:                         rpcService,
 		MaxSponsoredBaseReserves:           cfg.MaxSponsoredBaseReserves,
 		BaseFee:                            int64(cfg.BaseFee),
 		Models:                             models,
@@ -178,50 +178,31 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 		return handlerDeps{}, fmt.Errorf("instantiating payment service: %w", err)
 	}
 
-	channelAccountService, err := services.NewChannelAccountService(services.ChannelAccountServiceOptions{
-		DB:                                 dbConnectionPool,
-		HorizonClient:                      &horizonClient,
-		BaseFee:                            int64(cfg.BaseFee),
-		DistributionAccountSignatureClient: cfg.DistributionAccountSignatureClient,
-		ChannelAccountStore:                store.NewChannelAccountModel(dbConnectionPool),
-		PrivateKeyEncrypter:                &signingutils.DefaultPrivateKeyEncrypter{},
-		EncryptionPassphrase:               cfg.EncryptionPassphrase,
-	})
-	if err != nil {
-		return handlerDeps{}, fmt.Errorf("instantiating channel account service: %w", err)
-	}
-	go ensureChannelAccounts(channelAccountService, int64(cfg.NumberOfChannelAccounts))
-
 	// TSS setup
 	tssTxService, err := tssservices.NewTransactionService(tssservices.TransactionServiceOptions{
 		DistributionAccountSignatureClient: cfg.DistributionAccountSignatureClient,
 		ChannelAccountSignatureClient:      cfg.ChannelAccountSignatureClient,
-		HorizonClient:                      &horizonClient,
+		RPCService:                         rpcService,
 		BaseFee:                            int64(cfg.BaseFee),
 	})
 
 	if err != nil {
 		return handlerDeps{}, fmt.Errorf("instantiating tss transaction service: %w", err)
 	}
-	httpClient := http.Client{Timeout: time.Duration(30 * time.Second)}
-	rpcService, err := services.NewRPCService(cfg.RPCURL, &httpClient)
-	if err != nil {
-		return handlerDeps{}, fmt.Errorf("instantiating rpc service: %w", err)
-	}
 
-	store, err := tssstore.NewStore(dbConnectionPool)
+	tssStore, err := tssstore.NewStore(dbConnectionPool)
 	if err != nil {
 		return handlerDeps{}, fmt.Errorf("instantiating tss store: %w", err)
 	}
 	txManager := tssservices.NewTransactionManager(tssservices.TransactionManagerConfigs{
 		TxService:  tssTxService,
 		RPCService: rpcService,
-		Store:      store,
+		Store:      tssStore,
 	})
 
 	rpcCallerChannel := tsschannel.NewRPCCallerChannel(tsschannel.RPCCallerChannelConfigs{
 		TxManager:     txManager,
-		Store:         store,
+		Store:         tssStore,
 		MaxBufferSize: cfg.RPCCallerServiceChannelBufferSize,
 		MaxWorkers:    cfg.RPCCallerServiceChannelMaxWorkers,
 	})
@@ -245,7 +226,7 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 	httpClient = http.Client{Timeout: time.Duration(30 * time.Second)}
 	webhookChannel := tsschannel.NewWebhookChannel(tsschannel.WebhookChannelConfigs{
 		HTTPClient:           &httpClient,
-		Store:                store,
+		Store:                tssStore,
 		MaxBufferSize:        cfg.WebhookHandlerServiceChannelMaxBufferSize,
 		MaxWorkers:           cfg.WebhookHandlerServiceChannelMaxWorkers,
 		MaxRetries:           cfg.WebhookHandlerServiceChannelMaxRetries,
@@ -263,11 +244,25 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 	errorJitterChannel.SetRouter(router)
 	errorNonJitterChannel.SetRouter(router)
 
-	poolPopulator, err := tssservices.NewPoolPopulator(router, store, rpcService)
+	poolPopulator, err := tssservices.NewPoolPopulator(router, tssStore, rpcService)
 	if err != nil {
 		return handlerDeps{}, fmt.Errorf("instantiating tss pool populator")
 	}
 
+	channelAccountService, err := services.NewChannelAccountService(services.ChannelAccountServiceOptions{
+		DB:                                 dbConnectionPool,
+		RPCService:                         rpcService,
+		BaseFee:                            int64(cfg.BaseFee),
+		DistributionAccountSignatureClient: cfg.DistributionAccountSignatureClient,
+		ChannelAccountStore:                store.NewChannelAccountModel(dbConnectionPool),
+		PrivateKeyEncrypter:                &signingutils.DefaultPrivateKeyEncrypter{},
+		EncryptionPassphrase:               cfg.EncryptionPassphrase,
+	})
+	if err != nil {
+		return handlerDeps{}, fmt.Errorf("instantiating channel account service: %w", err)
+	}
+	go ensureChannelAccounts(channelAccountService, int64(cfg.NumberOfChannelAccounts))
+
 	return handlerDeps{
 		Models:                    models,
 		SignatureVerifier:         signatureVerifier,
@@ -284,7 +279,7 @@ func initHandlerDeps(cfg Configs) (handlerDeps, error) {
 		WebhookChannel:        webhookChannel,
 		TSSRouter:             router,
 		PoolPopulator:         poolPopulator,
-		TSSStore:              store,
+		TSSStore:              tssStore,
 		TSSTransactionService: tssTxService,
 	}, nil
 }

internal/services/account_sponsorship_service.go

@@ -6,10 +6,10 @@ import (
 	"fmt"
 	"slices"
 
-	"github.com/stellar/go/clients/horizonclient"
 	"github.com/stellar/go/support/log"
 	"github.com/stellar/go/txnbuild"
 	"github.com/stellar/go/xdr"
+
 	"github.com/stellar/wallet-backend/internal/data"
 	"github.com/stellar/wallet-backend/internal/entities"
 	"github.com/stellar/wallet-backend/internal/signing"
@@ -21,6 +21,7 @@ var (
 	ErrAccountNotEligibleForBeingSponsored = errors.New("account not eligible for being sponsored")
 	ErrFeeExceedsMaximumBaseFee            = errors.New("fee exceeds maximum base fee to sponsor")
 	ErrNoSignaturesProvided                = errors.New("should have at least one signature")
+	ErrAccountNotFound                     = errors.New("account not found")
 )
 
 type ErrOperationNotAllowed struct {
@@ -45,7 +46,7 @@ type AccountSponsorshipService interface {
 type accountSponsorshipService struct {
 	DistributionAccountSignatureClient signing.SignatureClient
 	ChannelAccountSignatureClient      signing.SignatureClient
-	HorizonClient                      horizonclient.ClientInterface
+	RPCService                         RPCService
 	MaxSponsoredBaseReserves           int
 	BaseFee                            int64
 	Models                             *data.Models
@@ -56,11 +57,11 @@ var _ AccountSponsorshipService = (*accountSponsorshipService)(nil)
 
 func (s *accountSponsorshipService) SponsorAccountCreationTransaction(ctx context.Context, accountToSponsor string, signers []entities.Signer, supportedAssets []entities.Asset) (string, string, error) {
 	// Check the accountToSponsor does not exist on Stellar
-	_, err := s.HorizonClient.AccountDetail(horizonclient.AccountRequest{AccountID: accountToSponsor})
+	_, err := s.RPCService.GetAccountLedgerSequence(accountToSponsor)
 	if err == nil {
 		return "", "", ErrAccountAlreadyExists
 	}
-	if !horizonclient.IsNotFoundError(err) {
+	if !errors.Is(err, ErrAccountNotFound) {
 		return "", "", fmt.Errorf("getting details for account %s: %w", accountToSponsor, err)
 	}
 
@@ -125,14 +126,17 @@ func (s *accountSponsorshipService) SponsorAccountCreationTransaction(ctx contex
 		return "", "", fmt.Errorf("getting channel account public key: %w", err)
 	}
 
-	channelAccount, err := s.HorizonClient.AccountDetail(horizonclient.AccountRequest{AccountID: channelAccountPublicKey})
+	channelAccountSeq, err := s.RPCService.GetAccountLedgerSequence(channelAccountPublicKey)
 	if err != nil {
-		return "", "", fmt.Errorf("getting distribution account details: %w", err)
+		return "", "", fmt.Errorf("getting sequence number for channel account public key: %s: %w", channelAccountPublicKey, err)
 	}
 
 	tx, err := txnbuild.NewTransaction(
 		txnbuild.TransactionParams{
-			SourceAccount:        &channelAccount,
+			SourceAccount: &txnbuild.SimpleAccount{
+				AccountID: channelAccountPublicKey,
+				Sequence:  channelAccountSeq,
+			},
 			IncrementSequenceNum: true,
 			Operations:           ops,
 			BaseFee:              s.BaseFee,
@@ -228,7 +232,7 @@ func (s *accountSponsorshipService) WrapTransaction(ctx context.Context, tx *txn
 type AccountSponsorshipServiceOptions struct {
 	DistributionAccountSignatureClient signing.SignatureClient
 	ChannelAccountSignatureClient      signing.SignatureClient
-	HorizonClient                      horizonclient.ClientInterface
+	RPCService                         RPCService
 	MaxSponsoredBaseReserves           int
 	BaseFee                            int64
 	Models                             *data.Models
@@ -240,12 +244,12 @@ func (o *AccountSponsorshipServiceOptions) Validate() error {
 		return fmt.Errorf("distribution account signature client cannot be nil")
 	}
 
-	if o.ChannelAccountSignatureClient == nil {
-		return fmt.Errorf("channel account signature client cannot be nil")
+	if o.RPCService == nil {
+		return fmt.Errorf("rpc client cannot be nil")
 	}
 
-	if o.HorizonClient == nil {
-		return fmt.Errorf("horizon client cannot be nil")
+	if o.ChannelAccountSignatureClient == nil {
+		return fmt.Errorf("channel account signature client cannot be nil")
 	}
 
 	if o.BaseFee < int64(txnbuild.MinBaseFee) {
@@ -267,7 +271,7 @@ func NewAccountSponsorshipService(opts AccountSponsorshipServiceOptions) (*accou
 	return &accountSponsorshipService{
 		DistributionAccountSignatureClient: opts.DistributionAccountSignatureClient,
 		ChannelAccountSignatureClient:      opts.ChannelAccountSignatureClient,
-		HorizonClient:                      opts.HorizonClient,
+		RPCService:                         opts.RPCService,
 		MaxSponsoredBaseReserves:           opts.MaxSponsoredBaseReserves,
 		BaseFee:                            opts.BaseFee,
 		Models:                             opts.Models,