quotation bff

api/payments/orchestrator/internal/service/orchestrator/convert.go

@@ -97,6 +97,7 @@ func quoteSnapshotToModel(src *orchestratorv1.PaymentQuote) *model.PaymentQuoteS
 		FXQuote:                  cloneFXQuote(src.GetFxQuote()),
 		NetworkFee:               cloneNetworkEstimate(src.GetNetworkFee()),
 		FeeQuoteToken:            strings.TrimSpace(src.GetFeeQuoteToken()),
+		QuoteRef:                 strings.TrimSpace(src.GetQuoteRef()),
 	}
 }
 
@@ -220,6 +221,7 @@ func modelQuoteToProto(src *model.PaymentQuoteSnapshot) *orchestratorv1.PaymentQ
 		FxQuote:                  cloneFXQuote(src.FXQuote),
 		NetworkFee:               cloneNetworkEstimate(src.NetworkFee),
 		FeeQuoteToken:            src.FeeQuoteToken,
+		QuoteRef:                 strings.TrimSpace(src.QuoteRef),
 	}
 }
 

api/payments/orchestrator/internal/service/orchestrator/execution.go

@@ -19,13 +19,13 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*orchestratorv1.PaymentQuote, error) {
+func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*orchestratorv1.PaymentQuote, time.Time, error) {
 	intent := req.GetIntent()
 	amount := intent.GetAmount()
 	baseAmount := cloneMoney(amount)
 	feeQuote, err := s.quoteFees(ctx, orgRef, req)
 	if err != nil {
-		return nil, err
+		return nil, time.Time{}, err
 	}
 	feeTotal := extractFeeTotal(feeQuote.GetLines(), amount.GetCurrency())
 
@@ -33,7 +33,7 @@ func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orc
 	if shouldEstimateNetworkFee(intent) {
 		networkFee, err = s.estimateNetworkFee(ctx, intent)
 		if err != nil {
-			return nil, err
+			return nil, time.Time{}, err
 		}
 	}
 
@@ -41,13 +41,13 @@ func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orc
 	if shouldRequestFX(intent) {
 		fxQuote, err = s.requestFXQuote(ctx, orgRef, req)
 		if err != nil {
-			return nil, err
+			return nil, time.Time{}, err
 		}
 	}
 
 	debitAmount, settlementAmount := computeAggregates(baseAmount, feeTotal, networkFee)
 
-	return &orchestratorv1.PaymentQuote{
+	quote := &orchestratorv1.PaymentQuote{
 		DebitAmount:              debitAmount,
 		ExpectedSettlementAmount: settlementAmount,
 		ExpectedFeeTotal:         feeTotal,
@@ -56,7 +56,11 @@ func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orc
 		FxQuote:                  fxQuote,
 		NetworkFee:               networkFee,
 		FeeQuoteToken:            feeQuote.GetFeeQuoteToken(),
-	}, nil
+	}
+
+	expiresAt := quoteExpiry(s.clock.Now(), feeQuote, fxQuote)
+
+	return quote, expiresAt, nil
 }
 
 func (s *Service) quoteFees(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*feesv1.PrecomputeFeesResponse, error) {

api/payments/orchestrator/internal/service/orchestrator/helpers.go

@@ -2,6 +2,7 @@ package orchestrator
 
 import (
 	"strings"
+	"time"
 
 	"github.com/shopspring/decimal"
 	oracleclient "github.com/tech/sendico/fx/oracle/client"
@@ -219,6 +220,23 @@ func ledgerLineTypeFromAccounting(lineType accountingv1.PostingLineType) ledgerv
 	}
 }
 
+func quoteExpiry(now time.Time, feeQuote *feesv1.PrecomputeFeesResponse, fxQuote *oraclev1.Quote) time.Time {
+	expiry := time.Time{}
+	if feeQuote != nil && feeQuote.GetExpiresAt() != nil {
+		expiry = feeQuote.GetExpiresAt().AsTime()
+	}
+	if expiry.IsZero() {
+		expiry = now.Add(time.Duration(defaultFeeQuoteTTLMillis) * time.Millisecond)
+	}
+	if fxQuote != nil && fxQuote.GetExpiresAtUnixMs() > 0 {
+		fxExpiry := time.UnixMilli(fxQuote.GetExpiresAtUnixMs()).UTC()
+		if fxExpiry.Before(expiry) {
+			expiry = fxExpiry
+		}
+	}
+	return expiry
+}
+
 func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*chainv1.ServiceFeeBreakdown {
 	if quote == nil {
 		return nil

api/payments/orchestrator/internal/service/orchestrator/options.go

@@ -3,8 +3,8 @@ package orchestrator
 import (
 	"time"
 
-	chainclient "github.com/tech/sendico/gateway/chain/client"
 	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
 	ledgerclient "github.com/tech/sendico/ledger/client"
 	clockpkg "github.com/tech/sendico/pkg/clock"
 	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"

api/payments/orchestrator/internal/service/orchestrator/service.go

@@ -16,6 +16,7 @@ import (
 	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"google.golang.org/grpc"
+	"google.golang.org/protobuf/proto"
 )
 
 type serviceError string
@@ -132,6 +133,10 @@ func (s *Service) quotePaymentHandler(ctx context.Context, req *orchestratorv1.Q
 	if orgRef == "" {
 		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref is required"))
 	}
+	orgObjectID, parseErr := primitive.ObjectIDFromHex(orgRef)
+	if parseErr != nil {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref must be a valid objectID"))
+	}
 	intent := req.GetIntent()
 	if intent == nil {
 		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent is required"))
@@ -140,11 +145,31 @@ func (s *Service) quotePaymentHandler(ctx context.Context, req *orchestratorv1.Q
 		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent.amount is required"))
 	}
 
-	quote, err := s.buildPaymentQuote(ctx, orgRef, req)
+	quote, expiresAt, err := s.buildPaymentQuote(ctx, orgRef, req)
 	if err != nil {
 		return gsresponse.Auto[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
 	}
 
+	if !req.GetPreviewOnly() {
+		quotesStore := s.storage.Quotes()
+		if quotesStore == nil {
+			return gsresponse.Unavailable[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+		}
+		quoteRef := primitive.NewObjectID().Hex()
+		quote.QuoteRef = quoteRef
+		record := &model.PaymentQuoteRecord{
+			QuoteRef:  quoteRef,
+			Intent:    intentFromProto(intent),
+			Quote:     quoteSnapshotToModel(quote),
+			ExpiresAt: expiresAt,
+		}
+		record.SetID(primitive.NewObjectID())
+		record.SetOrganizationRef(orgObjectID)
+		if err := quotesStore.Create(ctx, record); err != nil {
+			return gsresponse.Auto[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+	}
+
 	return gsresponse.Success(&orchestratorv1.QuotePaymentResponse{Quote: quote})
 }
 
@@ -194,10 +219,34 @@ func (s *Service) initiatePaymentHandler(ctx context.Context, req *orchestratorv
 		return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
 	}
 
-	quote := req.GetFeeQuoteToken()
+	quoteRef := strings.TrimSpace(req.GetQuoteRef())
+	quote := strings.TrimSpace(req.GetFeeQuoteToken())
 	var quoteSnapshot *orchestratorv1.PaymentQuote
-	if quote == "" {
-		quoteSnapshot, err = s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
+	if quoteRef != "" {
+		quotesStore := s.storage.Quotes()
+		if quotesStore == nil {
+			return gsresponse.Unavailable[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+		}
+		record, err := quotesStore.GetByRef(ctx, orgObjectID, quoteRef)
+		if err != nil {
+			if err == storage.ErrQuoteNotFound {
+				return gsresponse.FailedPrecondition[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, "quote_not_found", merrors.InvalidArgument("quote_ref not found or expired"))
+			}
+			return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+		if !record.ExpiresAt.IsZero() && s.clock.Now().After(record.ExpiresAt) {
+			return gsresponse.FailedPrecondition[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, "quote_expired", merrors.InvalidArgument("quote_ref expired"))
+		}
+		if !proto.Equal(protoIntentFromModel(record.Intent), intent) {
+			return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("quote_ref does not match intent"))
+		}
+		quoteSnapshot = modelQuoteToProto(record.Quote)
+		if quoteSnapshot == nil {
+			return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("stored quote is empty"))
+		}
+		quoteSnapshot.QuoteRef = quoteRef
+	} else if quote == "" {
+		quoteSnapshot, _, err = s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
 			Meta:           req.GetMeta(),
 			IdempotencyKey: req.GetIdempotencyKey(),
 			Intent:         req.GetIntent(),
@@ -389,7 +438,7 @@ func (s *Service) initiateConversionHandler(ctx context.Context, req *orchestrat
 		FeePolicy:   req.GetFeePolicy(),
 	}
 
-	quote, err := s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
+	quote, _, err := s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
 		Meta:           req.GetMeta(),
 		IdempotencyKey: req.GetIdempotencyKey(),
 		Intent:         intentProto,

api/payments/orchestrator/internal/service/orchestrator/service_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/tech/sendico/payments/orchestrator/storage"
 	"github.com/tech/sendico/payments/orchestrator/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
+	"github.com/tech/sendico/pkg/merrors"
 	mo "github.com/tech/sendico/pkg/model"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
 	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
@@ -208,11 +209,43 @@ func TestProcessDepositObservedHandler_MatchesPayment(t *testing.T) {
 // ----------------------------------------------------------------------
 
 type stubRepository struct {
-	store *stubPaymentsStore
+	store  *stubPaymentsStore
+	quotes storage.QuotesStore
 }
 
 func (r *stubRepository) Ping(context.Context) error      { return nil }
 func (r *stubRepository) Payments() storage.PaymentsStore { return r.store }
+func (r *stubRepository) Quotes() storage.QuotesStore {
+	if r.quotes != nil {
+		return r.quotes
+	}
+	return &stubQuotesStore{}
+}
+
+type stubQuotesStore struct {
+	quotes map[string]*model.PaymentQuoteRecord
+}
+
+func (s *stubQuotesStore) Create(ctx context.Context, quote *model.PaymentQuoteRecord) error {
+	if quote == nil {
+		return merrors.InvalidArgument("nil quote")
+	}
+	if s.quotes == nil {
+		s.quotes = map[string]*model.PaymentQuoteRecord{}
+	}
+	s.quotes[strings.TrimSpace(quote.QuoteRef)] = quote
+	return nil
+}
+
+func (s *stubQuotesStore) GetByRef(ctx context.Context, orgRef primitive.ObjectID, quoteRef string) (*model.PaymentQuoteRecord, error) {
+	if s.quotes == nil {
+		return nil, storage.ErrQuoteNotFound
+	}
+	if q, ok := s.quotes[strings.TrimSpace(quoteRef)]; ok {
+		return q, nil
+	}
+	return nil, storage.ErrQuoteNotFound
+}
 
 type stubPaymentsStore struct {
 	payments map[string]*model.Payment