Setup local nonce pool in sequencer service

Author: Jeff Yanta

pkg/code/async/sequencer/fulfillment_handler.go

@@ -46,7 +46,7 @@ type FulfillmentHandler interface {
 	// to the blockchain. This is an optimization for the nonce pool. Implementations
 	// should not modify the provided fulfillment record or selected nonce, but rather
 	// use relevant fields to make the corresponding transaction.
-	MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error)
+	MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error)
 
 	// OnSuccess is a callback function executed on a finalized transaction.
 	OnSuccess(ctx context.Context, fulfillmentRecord *fulfillment.Record, txnRecord *transaction.Record) error
@@ -123,7 +123,7 @@ func (h *InitializeLockedTimelockAccountFulfillmentHandler) SupportsOnDemandTran
 	return true
 }
 
-func (h *InitializeLockedTimelockAccountFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error) {
+func (h *InitializeLockedTimelockAccountFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error) {
 	if fulfillmentRecord.FulfillmentType != fulfillment.InitializeLockedTimelockAccount {
 		return nil, errors.New("invalid fulfillment type")
 	}
@@ -268,7 +268,7 @@ func (h *NoPrivacyTransferWithAuthorityFulfillmentHandler) SupportsOnDemandTrans
 	return true
 }
 
-func (h *NoPrivacyTransferWithAuthorityFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error) {
+func (h *NoPrivacyTransferWithAuthorityFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error) {
 	virtualSignatureBytes, err := base58.Decode(*fulfillmentRecord.VirtualSignature)
 	if err != nil {
 		return nil, err
@@ -444,7 +444,7 @@ func (h *NoPrivacyWithdrawFulfillmentHandler) SupportsOnDemandTransactions() boo
 	return true
 }
 
-func (h *NoPrivacyWithdrawFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error) {
+func (h *NoPrivacyWithdrawFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error) {
 	virtualSignatureBytes, err := base58.Decode(*fulfillmentRecord.VirtualSignature)
 	if err != nil {
 		return nil, err
@@ -634,7 +634,7 @@ func (h *CloseEmptyTimelockAccountFulfillmentHandler) SupportsOnDemandTransactio
 	return true
 }
 
-func (h *CloseEmptyTimelockAccountFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error) {
+func (h *CloseEmptyTimelockAccountFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error) {
 	if fulfillmentRecord.FulfillmentType != fulfillment.CloseEmptyTimelockAccount {
 		return nil, errors.New("invalid fulfillment type")
 	}

pkg/code/async/sequencer/service.go

@@ -14,6 +14,8 @@ import (
 	"github.com/code-payments/code-server/pkg/code/data/action"
 	"github.com/code-payments/code-server/pkg/code/data/fulfillment"
 	"github.com/code-payments/code-server/pkg/code/data/intent"
+	"github.com/code-payments/code-server/pkg/code/data/nonce"
+	"github.com/code-payments/code-server/pkg/code/transaction"
 )
 
 var (
@@ -28,22 +30,35 @@ type service struct {
 	data                      code_data.Provider
 	scheduler                 Scheduler
 	vmIndexerClient           indexerpb.IndexerClient
+	noncePool                 *transaction.LocalNoncePool
 	fulfillmentHandlersByType map[fulfillment.Type]FulfillmentHandler
 	actionHandlersByType      map[action.Type]ActionHandler
 	intentHandlersByType      map[intent.Type]IntentHandler
 }
 
-func New(data code_data.Provider, scheduler Scheduler, vmIndexerClient indexerpb.IndexerClient, configProvider ConfigProvider) async.Service {
+func New(data code_data.Provider, scheduler Scheduler, vmIndexerClient indexerpb.IndexerClient, noncePool *transaction.LocalNoncePool, configProvider ConfigProvider) (async.Service, error) {
+	noncePoolEnv, noncePoolEnvInstance, noncePoolType := noncePool.GetConfiguration()
+	if noncePoolEnv != nonce.EnvironmentSolana {
+		return nil, errors.Errorf("nonce pool environment must be %s", nonce.EnvironmentSolana)
+	}
+	if noncePoolEnvInstance != nonce.EnvironmentInstanceSolanaMainnet {
+		return nil, errors.Errorf("nonce pool environment instance must be %s", nonce.EnvironmentInstanceSolanaMainnet)
+	}
+	if noncePoolType != nonce.PurposeOnDemandTransaction {
+		return nil, errors.Errorf("nonce pool type must be %s", nonce.PurposeOnDemandTransaction)
+	}
+
 	return &service{
 		log:                       logrus.StandardLogger().WithField("service", "sequencer"),
 		conf:                      configProvider(),
 		data:                      data,
 		scheduler:                 scheduler,
 		vmIndexerClient:           vmIndexerClient,
+		noncePool:                 noncePool, // todo: validate configuration
 		fulfillmentHandlersByType: getFulfillmentHandlers(data, vmIndexerClient),
 		actionHandlersByType:      getActionHandlers(data),
 		intentHandlersByType:      getIntentHandlers(data),
-	}
+	}, nil
 }
 
 func (p *service) Start(ctx context.Context, interval time.Duration) error {

pkg/code/async/sequencer/testutil.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"errors"
 
-	"github.com/code-payments/code-server/pkg/solana"
-	"github.com/code-payments/code-server/pkg/solana/memo"
 	"github.com/code-payments/code-server/pkg/code/common"
 	"github.com/code-payments/code-server/pkg/code/data/fulfillment"
 	"github.com/code-payments/code-server/pkg/code/data/transaction"
 	transaction_util "github.com/code-payments/code-server/pkg/code/transaction"
+	"github.com/code-payments/code-server/pkg/solana"
+	"github.com/code-payments/code-server/pkg/solana/memo"
 )
 
 type mockScheduler struct {
@@ -42,7 +42,7 @@ func (h *mockFulfillmentHandler) SupportsOnDemandTransactions() bool {
 	return h.supportsOnDemandTxnCreation
 }
 
-func (h *mockFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error) {
+func (h *mockFulfillmentHandler) MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.Nonce) (*solana.Transaction, error) {
 	if !h.supportsOnDemandTxnCreation {
 		return nil, errors.New("not supported")
 	}

pkg/code/async/sequencer/worker.go

@@ -12,9 +12,7 @@ import (
 
 	"github.com/code-payments/code-server/pkg/code/common"
 	"github.com/code-payments/code-server/pkg/code/data/fulfillment"
-	"github.com/code-payments/code-server/pkg/code/data/nonce"
 	"github.com/code-payments/code-server/pkg/code/data/transaction"
-	transaction_util "github.com/code-payments/code-server/pkg/code/transaction"
 	"github.com/code-payments/code-server/pkg/database/query"
 	"github.com/code-payments/code-server/pkg/metrics"
 	"github.com/code-payments/code-server/pkg/pointer"
@@ -225,13 +223,12 @@ func (p *service) handlePending(ctx context.Context, record *fulfillment.Record)
 			return errors.New("unexpected scheduled fulfillment without transaction data")
 		}
 
-		selectedNonce, err := transaction_util.SelectAvailableNonce(ctx, p.data, nonce.EnvironmentSolana, nonce.EnvironmentInstanceSolanaMainnet, nonce.PurposeOnDemandTransaction)
+		selectedNonce, err := p.noncePool.GetNonce(ctx)
 		if err != nil {
 			return err
 		}
 		defer func() {
 			selectedNonce.ReleaseIfNotReserved()
-			selectedNonce.Unlock()
 		}()
 
 		err = p.data.ExecuteInTx(ctx, sql.LevelDefault, func(ctx context.Context) error {

pkg/code/async/sequencer/worker_test.go

@@ -105,6 +105,7 @@ func TestFulfillmentWorker_StatePending_OnDemandTransactionCreation_HappyPath(t
 	env.fulfillmentHandler.supportsOnDemandTxnCreation = true
 
 	nonceRecord := env.generateAvailableNonce(t)
+	time.Sleep(time.Second) // todo: Better way of waiting for nonce to be claimed
 
 	fulfillmentRecord := env.createAnyFulfillmentInState(t, fulfillment.StatePending)
 	fulfillmentRecord.Signature = nil
@@ -226,12 +227,23 @@ func setupWorkerEnv(t *testing.T) *workerTestEnv {
 	db := code_data.NewTestDataProvider()
 
 	scheduler := &mockScheduler{}
+	noncePool, err := transaction_util.NewLocalNoncePool(
+		db,
+		nil,
+		nonce.EnvironmentSolana,
+		nonce.EnvironmentInstanceSolanaMainnet,
+		nonce.PurposeOnDemandTransaction,
+		transaction_util.WithNoncePoolRefreshPoolInterval(time.Second),
+	)
+	require.NoError(t, err)
 	fulfillmentHandler := &mockFulfillmentHandler{}
 	actionHandler := &mockActionHandler{}
 	intentHandler := &mockIntentHandler{}
 
 	// todo: setup a test vm indexer
-	worker := New(db, scheduler, nil, withManualTestOverrides(&testOverrides{})).(*service)
+	workerInterface, err := New(db, scheduler, nil, noncePool, withManualTestOverrides(&testOverrides{}))
+	require.NoError(t, err)
+	worker := workerInterface.(*service)
 	for key := range worker.fulfillmentHandlersByType {
 		worker.fulfillmentHandlersByType[key] = fulfillmentHandler
 	}