service backend

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

@@ -0,0 +1,426 @@
+package orchestrator
+
+import (
+	"strings"
+	"time"
+
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/merrors"
+	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	fxv1 "github.com/tech/sendico/pkg/proto/common/fx/v1"
+	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func intentFromProto(src *orchestratorv1.PaymentIntent) model.PaymentIntent {
+	if src == nil {
+		return model.PaymentIntent{}
+	}
+	intent := model.PaymentIntent{
+		Kind:        modelKindFromProto(src.GetKind()),
+		Source:      endpointFromProto(src.GetSource()),
+		Destination: endpointFromProto(src.GetDestination()),
+		Amount:      cloneMoney(src.GetAmount()),
+		RequiresFX:  src.GetRequiresFx(),
+		FeePolicy:   src.GetFeePolicy(),
+		Attributes:  cloneMetadata(src.GetAttributes()),
+	}
+	if src.GetFx() != nil {
+		intent.FX = fxIntentFromProto(src.GetFx())
+	}
+	return intent
+}
+
+func endpointFromProto(src *orchestratorv1.PaymentEndpoint) model.PaymentEndpoint {
+	if src == nil {
+		return model.PaymentEndpoint{Type: model.EndpointTypeUnspecified}
+	}
+	result := model.PaymentEndpoint{
+		Type:     model.EndpointTypeUnspecified,
+		Metadata: cloneMetadata(src.GetMetadata()),
+	}
+	if ledger := src.GetLedger(); ledger != nil {
+		result.Type = model.EndpointTypeLedger
+		result.Ledger = &model.LedgerEndpoint{
+			LedgerAccountRef:       strings.TrimSpace(ledger.GetLedgerAccountRef()),
+			ContraLedgerAccountRef: strings.TrimSpace(ledger.GetContraLedgerAccountRef()),
+		}
+		return result
+	}
+	if managed := src.GetManagedWallet(); managed != nil {
+		result.Type = model.EndpointTypeManagedWallet
+		result.ManagedWallet = &model.ManagedWalletEndpoint{
+			ManagedWalletRef: strings.TrimSpace(managed.GetManagedWalletRef()),
+			Asset:            cloneAsset(managed.GetAsset()),
+		}
+		return result
+	}
+	if external := src.GetExternalChain(); external != nil {
+		result.Type = model.EndpointTypeExternalChain
+		result.ExternalChain = &model.ExternalChainEndpoint{
+			Asset:   cloneAsset(external.GetAsset()),
+			Address: strings.TrimSpace(external.GetAddress()),
+			Memo:    strings.TrimSpace(external.GetMemo()),
+		}
+		return result
+	}
+	return result
+}
+
+func fxIntentFromProto(src *orchestratorv1.FXIntent) *model.FXIntent {
+	if src == nil {
+		return nil
+	}
+	return &model.FXIntent{
+		Pair:              clonePair(src.GetPair()),
+		Side:              src.GetSide(),
+		Firm:              src.GetFirm(),
+		TTLMillis:         src.GetTtlMs(),
+		PreferredProvider: strings.TrimSpace(src.GetPreferredProvider()),
+		MaxAgeMillis:      src.GetMaxAgeMs(),
+	}
+}
+
+func quoteSnapshotToModel(src *orchestratorv1.PaymentQuote) *model.PaymentQuoteSnapshot {
+	if src == nil {
+		return nil
+	}
+	return &model.PaymentQuoteSnapshot{
+		DebitAmount:              cloneMoney(src.GetDebitAmount()),
+		ExpectedSettlementAmount: cloneMoney(src.GetExpectedSettlementAmount()),
+		ExpectedFeeTotal:         cloneMoney(src.GetExpectedFeeTotal()),
+		FeeLines:                 cloneFeeLines(src.GetFeeLines()),
+		FeeRules:                 cloneFeeRules(src.GetFeeRules()),
+		FXQuote:                  cloneFXQuote(src.GetFxQuote()),
+		NetworkFee:               cloneNetworkEstimate(src.GetNetworkFee()),
+		FeeQuoteToken:            strings.TrimSpace(src.GetFeeQuoteToken()),
+	}
+}
+
+func toProtoPayment(src *model.Payment) *orchestratorv1.Payment {
+	if src == nil {
+		return nil
+	}
+	payment := &orchestratorv1.Payment{
+		PaymentRef:     src.PaymentRef,
+		IdempotencyKey: src.IdempotencyKey,
+		Intent:         protoIntentFromModel(src.Intent),
+		State:          protoStateFromModel(src.State),
+		FailureCode:    protoFailureFromModel(src.FailureCode),
+		FailureReason:  src.FailureReason,
+		LastQuote:      modelQuoteToProto(src.LastQuote),
+		Execution:      protoExecutionFromModel(src.Execution),
+		Metadata:       cloneMetadata(src.Metadata),
+	}
+	if src.CreatedAt.IsZero() {
+		payment.CreatedAt = timestamppb.New(time.Now().UTC())
+	} else {
+		payment.CreatedAt = timestamppb.New(src.CreatedAt.UTC())
+	}
+	if src.UpdatedAt != (time.Time{}) {
+		payment.UpdatedAt = timestamppb.New(src.UpdatedAt.UTC())
+	}
+	return payment
+}
+
+func protoIntentFromModel(src model.PaymentIntent) *orchestratorv1.PaymentIntent {
+	intent := &orchestratorv1.PaymentIntent{
+		Kind:        protoKindFromModel(src.Kind),
+		Source:      protoEndpointFromModel(src.Source),
+		Destination: protoEndpointFromModel(src.Destination),
+		Amount:      cloneMoney(src.Amount),
+		RequiresFx:  src.RequiresFX,
+		FeePolicy:   src.FeePolicy,
+		Attributes:  cloneMetadata(src.Attributes),
+	}
+	if src.FX != nil {
+		intent.Fx = protoFXIntentFromModel(src.FX)
+	}
+	return intent
+}
+
+func protoEndpointFromModel(src model.PaymentEndpoint) *orchestratorv1.PaymentEndpoint {
+	endpoint := &orchestratorv1.PaymentEndpoint{
+		Metadata: cloneMetadata(src.Metadata),
+	}
+	switch src.Type {
+	case model.EndpointTypeLedger:
+		if src.Ledger != nil {
+			endpoint.Endpoint = &orchestratorv1.PaymentEndpoint_Ledger{
+				Ledger: &orchestratorv1.LedgerEndpoint{
+					LedgerAccountRef:       src.Ledger.LedgerAccountRef,
+					ContraLedgerAccountRef: src.Ledger.ContraLedgerAccountRef,
+				},
+			}
+		}
+	case model.EndpointTypeManagedWallet:
+		if src.ManagedWallet != nil {
+			endpoint.Endpoint = &orchestratorv1.PaymentEndpoint_ManagedWallet{
+				ManagedWallet: &orchestratorv1.ManagedWalletEndpoint{
+					ManagedWalletRef: src.ManagedWallet.ManagedWalletRef,
+					Asset:            cloneAsset(src.ManagedWallet.Asset),
+				},
+			}
+		}
+	case model.EndpointTypeExternalChain:
+		if src.ExternalChain != nil {
+			endpoint.Endpoint = &orchestratorv1.PaymentEndpoint_ExternalChain{
+				ExternalChain: &orchestratorv1.ExternalChainEndpoint{
+					Asset:   cloneAsset(src.ExternalChain.Asset),
+					Address: src.ExternalChain.Address,
+					Memo:    src.ExternalChain.Memo,
+				},
+			}
+		}
+	default:
+		// leave unspecified
+	}
+	return endpoint
+}
+
+func protoFXIntentFromModel(src *model.FXIntent) *orchestratorv1.FXIntent {
+	if src == nil {
+		return nil
+	}
+	return &orchestratorv1.FXIntent{
+		Pair:              clonePair(src.Pair),
+		Side:              src.Side,
+		Firm:              src.Firm,
+		TtlMs:             src.TTLMillis,
+		PreferredProvider: src.PreferredProvider,
+		MaxAgeMs:          src.MaxAgeMillis,
+	}
+}
+
+func protoExecutionFromModel(src *model.ExecutionRefs) *orchestratorv1.ExecutionRefs {
+	if src == nil {
+		return nil
+	}
+	return &orchestratorv1.ExecutionRefs{
+		DebitEntryRef:    src.DebitEntryRef,
+		CreditEntryRef:   src.CreditEntryRef,
+		FxEntryRef:       src.FXEntryRef,
+		ChainTransferRef: src.ChainTransferRef,
+	}
+}
+
+func modelQuoteToProto(src *model.PaymentQuoteSnapshot) *orchestratorv1.PaymentQuote {
+	if src == nil {
+		return nil
+	}
+	return &orchestratorv1.PaymentQuote{
+		DebitAmount:              cloneMoney(src.DebitAmount),
+		ExpectedSettlementAmount: cloneMoney(src.ExpectedSettlementAmount),
+		ExpectedFeeTotal:         cloneMoney(src.ExpectedFeeTotal),
+		FeeLines:                 cloneFeeLines(src.FeeLines),
+		FeeRules:                 cloneFeeRules(src.FeeRules),
+		FxQuote:                  cloneFXQuote(src.FXQuote),
+		NetworkFee:               cloneNetworkEstimate(src.NetworkFee),
+		FeeQuoteToken:            src.FeeQuoteToken,
+	}
+}
+
+func filterFromProto(req *orchestratorv1.ListPaymentsRequest) *model.PaymentFilter {
+	if req == nil {
+		return &model.PaymentFilter{}
+	}
+	filter := &model.PaymentFilter{
+		SourceRef:      strings.TrimSpace(req.GetSourceRef()),
+		DestinationRef: strings.TrimSpace(req.GetDestinationRef()),
+	}
+	if req.GetPage() != nil {
+		filter.Cursor = strings.TrimSpace(req.GetPage().GetCursor())
+		filter.Limit = req.GetPage().GetLimit()
+	}
+	if len(req.GetFilterStates()) > 0 {
+		filter.States = make([]model.PaymentState, 0, len(req.GetFilterStates()))
+		for _, st := range req.GetFilterStates() {
+			filter.States = append(filter.States, modelStateFromProto(st))
+		}
+	}
+	return filter
+}
+
+func protoKindFromModel(kind model.PaymentKind) orchestratorv1.PaymentKind {
+	switch kind {
+	case model.PaymentKindPayout:
+		return orchestratorv1.PaymentKind_PAYMENT_KIND_PAYOUT
+	case model.PaymentKindInternalTransfer:
+		return orchestratorv1.PaymentKind_PAYMENT_KIND_INTERNAL_TRANSFER
+	case model.PaymentKindFXConversion:
+		return orchestratorv1.PaymentKind_PAYMENT_KIND_FX_CONVERSION
+	default:
+		return orchestratorv1.PaymentKind_PAYMENT_KIND_UNSPECIFIED
+	}
+}
+
+func modelKindFromProto(kind orchestratorv1.PaymentKind) model.PaymentKind {
+	switch kind {
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_PAYOUT:
+		return model.PaymentKindPayout
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_INTERNAL_TRANSFER:
+		return model.PaymentKindInternalTransfer
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_FX_CONVERSION:
+		return model.PaymentKindFXConversion
+	default:
+		return model.PaymentKindUnspecified
+	}
+}
+
+func protoStateFromModel(state model.PaymentState) orchestratorv1.PaymentState {
+	switch state {
+	case model.PaymentStateAccepted:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_ACCEPTED
+	case model.PaymentStateFundsReserved:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_FUNDS_RESERVED
+	case model.PaymentStateSubmitted:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_SUBMITTED
+	case model.PaymentStateSettled:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_SETTLED
+	case model.PaymentStateFailed:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_FAILED
+	case model.PaymentStateCancelled:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_CANCELLED
+	default:
+		return orchestratorv1.PaymentState_PAYMENT_STATE_UNSPECIFIED
+	}
+}
+
+func modelStateFromProto(state orchestratorv1.PaymentState) model.PaymentState {
+	switch state {
+	case orchestratorv1.PaymentState_PAYMENT_STATE_ACCEPTED:
+		return model.PaymentStateAccepted
+	case orchestratorv1.PaymentState_PAYMENT_STATE_FUNDS_RESERVED:
+		return model.PaymentStateFundsReserved
+	case orchestratorv1.PaymentState_PAYMENT_STATE_SUBMITTED:
+		return model.PaymentStateSubmitted
+	case orchestratorv1.PaymentState_PAYMENT_STATE_SETTLED:
+		return model.PaymentStateSettled
+	case orchestratorv1.PaymentState_PAYMENT_STATE_FAILED:
+		return model.PaymentStateFailed
+	case orchestratorv1.PaymentState_PAYMENT_STATE_CANCELLED:
+		return model.PaymentStateCancelled
+	default:
+		return model.PaymentStateUnspecified
+	}
+}
+
+func protoFailureFromModel(code model.PaymentFailureCode) orchestratorv1.PaymentFailureCode {
+	switch code {
+	case model.PaymentFailureCodeBalance:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_BALANCE
+	case model.PaymentFailureCodeLedger:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_LEDGER
+	case model.PaymentFailureCodeFX:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_FX
+	case model.PaymentFailureCodeChain:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_CHAIN
+	case model.PaymentFailureCodeFees:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_FEES
+	case model.PaymentFailureCodePolicy:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_POLICY
+	default:
+		return orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_UNSPECIFIED
+	}
+}
+
+func cloneAsset(asset *gatewayv1.Asset) *gatewayv1.Asset {
+	if asset == nil {
+		return nil
+	}
+	return &gatewayv1.Asset{
+		Chain:           asset.GetChain(),
+		TokenSymbol:     asset.GetTokenSymbol(),
+		ContractAddress: asset.GetContractAddress(),
+	}
+}
+
+func clonePair(pair *fxv1.CurrencyPair) *fxv1.CurrencyPair {
+	if pair == nil {
+		return nil
+	}
+	return &fxv1.CurrencyPair{
+		Base:  pair.GetBase(),
+		Quote: pair.GetQuote(),
+	}
+}
+
+func cloneFXQuote(quote *oraclev1.Quote) *oraclev1.Quote {
+	if quote == nil {
+		return nil
+	}
+	if cloned, ok := proto.Clone(quote).(*oraclev1.Quote); ok {
+		return cloned
+	}
+	return nil
+}
+
+func cloneNetworkEstimate(resp *gatewayv1.EstimateTransferFeeResponse) *gatewayv1.EstimateTransferFeeResponse {
+	if resp == nil {
+		return nil
+	}
+	if cloned, ok := proto.Clone(resp).(*gatewayv1.EstimateTransferFeeResponse); ok {
+		return cloned
+	}
+	return nil
+}
+
+func protoFailureToModel(code orchestratorv1.PaymentFailureCode) model.PaymentFailureCode {
+	switch code {
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_BALANCE:
+		return model.PaymentFailureCodeBalance
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_LEDGER:
+		return model.PaymentFailureCodeLedger
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_FX:
+		return model.PaymentFailureCodeFX
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_CHAIN:
+		return model.PaymentFailureCodeChain
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_FEES:
+		return model.PaymentFailureCodeFees
+	case orchestratorv1.PaymentFailureCode_PAYMENT_FAILURE_CODE_POLICY:
+		return model.PaymentFailureCodePolicy
+	default:
+		return model.PaymentFailureCodeUnspecified
+	}
+}
+
+func applyProtoPaymentToModel(src *orchestratorv1.Payment, dst *model.Payment) error {
+	if src == nil || dst == nil {
+		return merrors.InvalidArgument("payment payload is required")
+	}
+	dst.PaymentRef = strings.TrimSpace(src.GetPaymentRef())
+	dst.IdempotencyKey = strings.TrimSpace(src.GetIdempotencyKey())
+	dst.Intent = intentFromProto(src.GetIntent())
+	dst.State = modelStateFromProto(src.GetState())
+	dst.FailureCode = protoFailureToModel(src.GetFailureCode())
+	dst.FailureReason = strings.TrimSpace(src.GetFailureReason())
+	dst.Metadata = cloneMetadata(src.GetMetadata())
+	dst.LastQuote = quoteSnapshotToModel(src.GetLastQuote())
+	dst.Execution = executionFromProto(src.GetExecution())
+	return nil
+}
+
+func executionFromProto(src *orchestratorv1.ExecutionRefs) *model.ExecutionRefs {
+	if src == nil {
+		return nil
+	}
+	return &model.ExecutionRefs{
+		DebitEntryRef:    strings.TrimSpace(src.GetDebitEntryRef()),
+		CreditEntryRef:   strings.TrimSpace(src.GetCreditEntryRef()),
+		FXEntryRef:       strings.TrimSpace(src.GetFxEntryRef()),
+		ChainTransferRef: strings.TrimSpace(src.GetChainTransferRef()),
+	}
+}
+
+func ensurePageRequest(req *orchestratorv1.ListPaymentsRequest) *paginationv1.CursorPageRequest {
+	if req == nil {
+		return &paginationv1.CursorPageRequest{}
+	}
+	if req.GetPage() == nil {
+		return &paginationv1.CursorPageRequest{}
+	}
+	return req.GetPage()
+}

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

@@ -0,0 +1,495 @@
+package orchestrator
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	"github.com/tech/sendico/payments/orchestrator/storage"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/merrors"
+	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
+	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
+	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.uber.org/zap"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*orchestratorv1.PaymentQuote, error) {
+	intent := req.GetIntent()
+	amount := intent.GetAmount()
+	baseAmount := cloneMoney(amount)
+	feeQuote, err := s.quoteFees(ctx, orgRef, req)
+	if err != nil {
+		return nil, err
+	}
+	feeTotal := extractFeeTotal(feeQuote.GetLines(), amount.GetCurrency())
+
+	var networkFee *gatewayv1.EstimateTransferFeeResponse
+	if shouldEstimateNetworkFee(intent) {
+		networkFee, err = s.estimateNetworkFee(ctx, intent)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var fxQuote *oraclev1.Quote
+	if shouldRequestFX(intent) {
+		fxQuote, err = s.requestFXQuote(ctx, orgRef, req)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	debitAmount, settlementAmount := computeAggregates(baseAmount, feeTotal, networkFee)
+
+	return &orchestratorv1.PaymentQuote{
+		DebitAmount:              debitAmount,
+		ExpectedSettlementAmount: settlementAmount,
+		ExpectedFeeTotal:         feeTotal,
+		FeeLines:                 cloneFeeLines(feeQuote.GetLines()),
+		FeeRules:                 cloneFeeRules(feeQuote.GetApplied()),
+		FxQuote:                  fxQuote,
+		NetworkFee:               networkFee,
+		FeeQuoteToken:            feeQuote.GetFeeQuoteToken(),
+	}, nil
+}
+
+func (s *Service) quoteFees(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*feesv1.PrecomputeFeesResponse, error) {
+	if !s.fees.available() {
+		return &feesv1.PrecomputeFeesResponse{}, nil
+	}
+	intent := req.GetIntent()
+	feeIntent := &feesv1.Intent{
+		Trigger:    triggerFromKind(intent.GetKind(), intent.GetRequiresFx()),
+		BaseAmount: cloneMoney(intent.GetAmount()),
+		BookedAt:   timestamppb.New(s.clock.Now()),
+		OriginType: "payments.orchestrator.quote",
+		OriginRef:  strings.TrimSpace(req.GetIdempotencyKey()),
+		Attributes: cloneMetadata(intent.GetAttributes()),
+	}
+	timeout := req.GetMeta().GetTrace()
+	ctxTimeout, cancel := s.withTimeout(ctx, s.fees.timeout)
+	defer cancel()
+	resp, err := s.fees.client.PrecomputeFees(ctxTimeout, &feesv1.PrecomputeFeesRequest{
+		Meta: &feesv1.RequestMeta{
+			OrganizationRef: orgRef,
+			Trace:           timeout,
+		},
+		Intent: feeIntent,
+		TtlMs:  defaultFeeQuoteTTLMillis,
+	})
+	if err != nil {
+		s.logger.Error("fees precompute failed", zap.Error(err))
+		return nil, merrors.Internal("fees_precompute_failed")
+	}
+	return resp, nil
+}
+
+func (s *Service) estimateNetworkFee(ctx context.Context, intent *orchestratorv1.PaymentIntent) (*gatewayv1.EstimateTransferFeeResponse, error) {
+	if !s.gateway.available() {
+		return nil, nil
+	}
+
+	req := &gatewayv1.EstimateTransferFeeRequest{
+		Amount: cloneMoney(intent.GetAmount()),
+	}
+	if src := intent.GetSource().GetManagedWallet(); src != nil {
+		req.SourceWalletRef = strings.TrimSpace(src.GetManagedWalletRef())
+	}
+	if dst := intent.GetDestination().GetManagedWallet(); dst != nil {
+		req.Destination = &gatewayv1.TransferDestination{
+			Destination: &gatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(dst.GetManagedWalletRef())},
+		}
+	}
+	if dst := intent.GetDestination().GetExternalChain(); dst != nil {
+		req.Destination = &gatewayv1.TransferDestination{
+			Destination: &gatewayv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(dst.GetAddress())},
+			Memo:        strings.TrimSpace(dst.GetMemo()),
+		}
+		req.Asset = dst.GetAsset()
+	}
+	if req.Asset == nil {
+		if src := intent.GetSource().GetManagedWallet(); src != nil {
+			req.Asset = src.GetAsset()
+		}
+	}
+
+	resp, err := s.gateway.client.EstimateTransferFee(ctx, req)
+	if err != nil {
+		s.logger.Error("chain gateway fee estimation failed", zap.Error(err))
+		return nil, merrors.Internal("chain_gateway_fee_estimation_failed")
+	}
+	return resp, nil
+}
+
+func (s *Service) requestFXQuote(ctx context.Context, orgRef string, req *orchestratorv1.QuotePaymentRequest) (*oraclev1.Quote, error) {
+	if !s.oracle.available() {
+		return nil, nil
+	}
+	intent := req.GetIntent()
+	meta := req.GetMeta()
+	fxIntent := intent.GetFx()
+	if fxIntent == nil {
+		return nil, nil
+	}
+
+	ttl := fxIntent.GetTtlMs()
+	if ttl <= 0 {
+		ttl = defaultOracleTTLMillis
+	}
+
+	params := oracleclient.GetQuoteParams{
+		Meta: oracleclient.RequestMeta{
+			OrganizationRef: orgRef,
+			Trace:           meta.GetTrace(),
+		},
+		Pair:              fxIntent.GetPair(),
+		Side:              fxIntent.GetSide(),
+		Firm:              fxIntent.GetFirm(),
+		TTL:               time.Duration(ttl) * time.Millisecond,
+		PreferredProvider: strings.TrimSpace(fxIntent.GetPreferredProvider()),
+	}
+
+	if fxIntent.GetMaxAgeMs() > 0 {
+		params.MaxAge = time.Duration(fxIntent.GetMaxAgeMs()) * time.Millisecond
+	}
+
+	if amount := intent.GetAmount(); amount != nil {
+		params.BaseAmount = cloneMoney(amount)
+	}
+
+	quote, err := s.oracle.client.GetQuote(ctx, params)
+	if err != nil {
+		s.logger.Error("fx oracle quote failed", zap.Error(err))
+		return nil, merrors.Internal("fx_quote_failed")
+	}
+	return quoteToProto(quote), nil
+}
+
+func (s *Service) executePayment(ctx context.Context, store storage.PaymentsStore, payment *model.Payment, quote *orchestratorv1.PaymentQuote) error {
+	if store == nil {
+		return errStorageUnavailable
+	}
+
+	charges := ledgerChargesFromFeeLines(quote.GetFeeLines())
+	ledgerNeeded := requiresLedger(payment)
+	chainNeeded := requiresChain(payment)
+
+	exec := payment.Execution
+	if exec == nil {
+		exec = &model.ExecutionRefs{}
+	}
+
+	if ledgerNeeded {
+		if !s.ledger.available() {
+			return s.failPayment(ctx, store, payment, model.PaymentFailureCodeLedger, "ledger_client_unavailable", merrors.Internal("ledger_client_unavailable"))
+		}
+		if err := s.performLedgerOperation(ctx, payment, quote, charges); err != nil {
+			return s.failPayment(ctx, store, payment, model.PaymentFailureCodeLedger, strings.TrimSpace(err.Error()), err)
+		}
+		payment.State = model.PaymentStateFundsReserved
+		if err := s.persistPayment(ctx, store, payment); err != nil {
+			return err
+		}
+	}
+
+	if chainNeeded {
+		if !s.gateway.available() {
+			return s.failPayment(ctx, store, payment, model.PaymentFailureCodeChain, "chain_client_unavailable", merrors.Internal("chain_client_unavailable"))
+		}
+		resp, err := s.submitChainTransfer(ctx, payment, quote)
+		if err != nil {
+			return s.failPayment(ctx, store, payment, model.PaymentFailureCodeChain, strings.TrimSpace(err.Error()), err)
+		}
+		exec = payment.Execution
+		if exec == nil {
+			exec = &model.ExecutionRefs{}
+		}
+		if resp != nil && resp.GetTransfer() != nil {
+			exec.ChainTransferRef = strings.TrimSpace(resp.GetTransfer().GetTransferRef())
+		}
+		payment.Execution = exec
+		payment.State = model.PaymentStateSubmitted
+		if err := s.persistPayment(ctx, store, payment); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	payment.State = model.PaymentStateSettled
+	return s.persistPayment(ctx, store, payment)
+}
+
+func (s *Service) performLedgerOperation(ctx context.Context, payment *model.Payment, quote *orchestratorv1.PaymentQuote, charges []*ledgerv1.PostingLine) error {
+	intent := payment.Intent
+	if payment.OrganizationRef == primitive.NilObjectID {
+		return merrors.InvalidArgument("ledger: organization_ref is required")
+	}
+
+	amount := cloneMoney(intent.Amount)
+	if amount == nil {
+		return merrors.InvalidArgument("ledger: amount is required")
+	}
+
+	description := paymentDescription(payment)
+	metadata := cloneMetadata(payment.Metadata)
+	exec := payment.Execution
+	if exec == nil {
+		exec = &model.ExecutionRefs{}
+	}
+
+	switch intent.Kind {
+	case model.PaymentKindFXConversion:
+		if err := s.applyFX(ctx, payment, quote, charges, description, metadata, exec); err != nil {
+			return err
+		}
+	case model.PaymentKindInternalTransfer, model.PaymentKindPayout, model.PaymentKindUnspecified:
+		from, to, err := resolveLedgerAccounts(intent)
+		if err != nil {
+			return err
+		}
+		req := &ledgerv1.TransferRequest{
+			IdempotencyKey:       payment.IdempotencyKey,
+			OrganizationRef:      payment.OrganizationRef.Hex(),
+			FromLedgerAccountRef: from,
+			ToLedgerAccountRef:   to,
+			Money:                amount,
+			Description:          description,
+			Charges:              charges,
+			Metadata:             metadata,
+		}
+		resp, err := s.ledger.client.TransferInternal(ctx, req)
+		if err != nil {
+			return err
+		}
+		exec.DebitEntryRef = strings.TrimSpace(resp.GetJournalEntryRef())
+		payment.Execution = exec
+	default:
+		return merrors.InvalidArgument("ledger: unsupported payment kind")
+	}
+
+	return nil
+}
+
+func (s *Service) applyFX(ctx context.Context, payment *model.Payment, quote *orchestratorv1.PaymentQuote, charges []*ledgerv1.PostingLine, description string, metadata map[string]string, exec *model.ExecutionRefs) error {
+	intent := payment.Intent
+	source := intent.Source.Ledger
+	destination := intent.Destination.Ledger
+	if source == nil || destination == nil {
+		return merrors.InvalidArgument("ledger: fx conversion requires ledger source and destination")
+	}
+	fq := quote.GetFxQuote()
+	if fq == nil {
+		return merrors.InvalidArgument("ledger: fx quote missing")
+	}
+	fromMoney := cloneMoney(fq.GetBaseAmount())
+	if fromMoney == nil {
+		fromMoney = cloneMoney(intent.Amount)
+	}
+	toMoney := cloneMoney(fq.GetQuoteAmount())
+	if toMoney == nil {
+		toMoney = cloneMoney(quote.GetExpectedSettlementAmount())
+	}
+	rate := ""
+	if fq.GetPrice() != nil {
+		rate = fq.GetPrice().GetValue()
+	}
+	req := &ledgerv1.FXRequest{
+		IdempotencyKey:       payment.IdempotencyKey,
+		OrganizationRef:      payment.OrganizationRef.Hex(),
+		FromLedgerAccountRef: strings.TrimSpace(source.LedgerAccountRef),
+		ToLedgerAccountRef:   strings.TrimSpace(destination.LedgerAccountRef),
+		FromMoney:            fromMoney,
+		ToMoney:              toMoney,
+		Rate:                 rate,
+		Description:          description,
+		Charges:              charges,
+		Metadata:             metadata,
+	}
+	resp, err := s.ledger.client.ApplyFXWithCharges(ctx, req)
+	if err != nil {
+		return err
+	}
+	exec.FXEntryRef = strings.TrimSpace(resp.GetJournalEntryRef())
+	payment.Execution = exec
+	return nil
+}
+
+func (s *Service) submitChainTransfer(ctx context.Context, payment *model.Payment, quote *orchestratorv1.PaymentQuote) (*gatewayv1.SubmitTransferResponse, error) {
+	intent := payment.Intent
+	source := intent.Source.ManagedWallet
+	destination := intent.Destination
+	if source == nil || strings.TrimSpace(source.ManagedWalletRef) == "" {
+		return nil, merrors.InvalidArgument("chain: source managed wallet is required")
+	}
+	dest, err := toGatewayDestination(destination)
+	if err != nil {
+		return nil, err
+	}
+	amount := cloneMoney(intent.Amount)
+	if amount == nil {
+		return nil, merrors.InvalidArgument("chain: amount is required")
+	}
+	fees := feeBreakdownFromQuote(quote)
+	req := &gatewayv1.SubmitTransferRequest{
+		IdempotencyKey:  payment.IdempotencyKey,
+		OrganizationRef: payment.OrganizationRef.Hex(),
+		SourceWalletRef: strings.TrimSpace(source.ManagedWalletRef),
+		Destination:     dest,
+		Amount:          amount,
+		Fees:            fees,
+		Metadata:        cloneMetadata(payment.Metadata),
+		ClientReference: payment.PaymentRef,
+	}
+	return s.gateway.client.SubmitTransfer(ctx, req)
+}
+
+func (s *Service) persistPayment(ctx context.Context, store storage.PaymentsStore, payment *model.Payment) error {
+	if store == nil {
+		return errStorageUnavailable
+	}
+	return store.Update(ctx, payment)
+}
+
+func (s *Service) failPayment(ctx context.Context, store storage.PaymentsStore, payment *model.Payment, code model.PaymentFailureCode, reason string, err error) error {
+	payment.State = model.PaymentStateFailed
+	payment.FailureCode = code
+	payment.FailureReason = strings.TrimSpace(reason)
+	if store != nil {
+		if updateErr := store.Update(ctx, payment); updateErr != nil {
+			s.logger.Error("failed to persist payment failure", zap.Error(updateErr), zap.String("payment_ref", payment.PaymentRef))
+		}
+	}
+	if err != nil {
+		return err
+	}
+	return merrors.Internal(reason)
+}
+
+func resolveLedgerAccounts(intent model.PaymentIntent) (string, string, error) {
+	source := intent.Source.Ledger
+	destination := intent.Destination.Ledger
+	if source == nil || strings.TrimSpace(source.LedgerAccountRef) == "" {
+		return "", "", merrors.InvalidArgument("ledger: source account is required")
+	}
+	to := ""
+	if destination != nil && strings.TrimSpace(destination.LedgerAccountRef) != "" {
+		to = strings.TrimSpace(destination.LedgerAccountRef)
+	} else if strings.TrimSpace(source.ContraLedgerAccountRef) != "" {
+		to = strings.TrimSpace(source.ContraLedgerAccountRef)
+	}
+	if to == "" {
+		return "", "", merrors.InvalidArgument("ledger: destination account is required")
+	}
+	return strings.TrimSpace(source.LedgerAccountRef), to, nil
+}
+
+func paymentDescription(payment *model.Payment) string {
+	if payment == nil {
+		return ""
+	}
+	if val := strings.TrimSpace(payment.Intent.Attributes["description"]); val != "" {
+		return val
+	}
+	if payment.Metadata != nil {
+		if val := strings.TrimSpace(payment.Metadata["description"]); val != "" {
+			return val
+		}
+	}
+	return payment.PaymentRef
+}
+
+func requiresLedger(payment *model.Payment) bool {
+	if payment == nil {
+		return false
+	}
+	if payment.Intent.Kind == model.PaymentKindFXConversion {
+		return true
+	}
+	return hasLedgerEndpoint(payment.Intent.Source) || hasLedgerEndpoint(payment.Intent.Destination)
+}
+
+func requiresChain(payment *model.Payment) bool {
+	if payment == nil {
+		return false
+	}
+	if !hasManagedWallet(payment.Intent.Source) {
+		return false
+	}
+	switch payment.Intent.Destination.Type {
+	case model.EndpointTypeManagedWallet, model.EndpointTypeExternalChain:
+		return true
+	default:
+		return false
+	}
+}
+
+func hasLedgerEndpoint(endpoint model.PaymentEndpoint) bool {
+	return endpoint.Type == model.EndpointTypeLedger && endpoint.Ledger != nil && strings.TrimSpace(endpoint.Ledger.LedgerAccountRef) != ""
+}
+
+func hasManagedWallet(endpoint model.PaymentEndpoint) bool {
+	return endpoint.Type == model.EndpointTypeManagedWallet && endpoint.ManagedWallet != nil && strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef) != ""
+}
+
+func toGatewayDestination(endpoint model.PaymentEndpoint) (*gatewayv1.TransferDestination, error) {
+	switch endpoint.Type {
+	case model.EndpointTypeManagedWallet:
+		if endpoint.ManagedWallet == nil || strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef) == "" {
+			return nil, merrors.InvalidArgument("chain: destination managed wallet is required")
+		}
+		return &gatewayv1.TransferDestination{
+			Destination: &gatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef)},
+		}, nil
+	case model.EndpointTypeExternalChain:
+		if endpoint.ExternalChain == nil || strings.TrimSpace(endpoint.ExternalChain.Address) == "" {
+			return nil, merrors.InvalidArgument("chain: external address is required")
+		}
+		return &gatewayv1.TransferDestination{
+			Destination: &gatewayv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(endpoint.ExternalChain.Address)},
+			Memo:        strings.TrimSpace(endpoint.ExternalChain.Memo),
+		}, nil
+	default:
+		return nil, merrors.InvalidArgument("chain: unsupported destination type")
+	}
+}
+
+func applyTransferStatus(event *gatewayv1.TransferStatusChangedEvent, payment *model.Payment) {
+	if payment.Execution == nil {
+		payment.Execution = &model.ExecutionRefs{}
+	}
+	if event == nil || event.GetTransfer() == nil {
+		return
+	}
+	transfer := event.GetTransfer()
+	payment.Execution.ChainTransferRef = strings.TrimSpace(transfer.GetTransferRef())
+	reason := strings.TrimSpace(event.GetReason())
+	if reason == "" {
+		reason = strings.TrimSpace(transfer.GetFailureReason())
+	}
+	switch transfer.GetStatus() {
+	case gatewayv1.TransferStatus_TRANSFER_CONFIRMED:
+		payment.State = model.PaymentStateSettled
+		payment.FailureCode = model.PaymentFailureCodeUnspecified
+		payment.FailureReason = ""
+	case gatewayv1.TransferStatus_TRANSFER_FAILED:
+		payment.State = model.PaymentStateFailed
+		payment.FailureCode = model.PaymentFailureCodeChain
+		payment.FailureReason = reason
+	case gatewayv1.TransferStatus_TRANSFER_CANCELLED:
+		payment.State = model.PaymentStateCancelled
+		payment.FailureCode = model.PaymentFailureCodePolicy
+		payment.FailureReason = reason
+	case gatewayv1.TransferStatus_TRANSFER_SIGNING,
+		gatewayv1.TransferStatus_TRANSFER_PENDING,
+		gatewayv1.TransferStatus_TRANSFER_SUBMITTED:
+		payment.State = model.PaymentStateSubmitted
+	default:
+		// retain previous state
+	}
+}

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

@@ -0,0 +1,295 @@
+package orchestrator
+
+import (
+	"strings"
+
+	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	"github.com/tech/sendico/pkg/merrors"
+	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
+	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+	"github.com/shopspring/decimal"
+	"google.golang.org/protobuf/proto"
+
+	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
+	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	accountingv1 "github.com/tech/sendico/pkg/proto/common/accounting/v1"
+	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+)
+
+func cloneMoney(input *moneyv1.Money) *moneyv1.Money {
+	if input == nil {
+		return nil
+	}
+	return &moneyv1.Money{
+		Currency: input.GetCurrency(),
+		Amount:   input.GetAmount(),
+	}
+}
+
+func cloneMetadata(input map[string]string) map[string]string {
+	if len(input) == 0 {
+		return nil
+	}
+	clone := make(map[string]string, len(input))
+	for k, v := range input {
+		clone[k] = v
+	}
+	return clone
+}
+
+func cloneFeeLines(lines []*feesv1.DerivedPostingLine) []*feesv1.DerivedPostingLine {
+	if len(lines) == 0 {
+		return nil
+	}
+	out := make([]*feesv1.DerivedPostingLine, 0, len(lines))
+	for _, line := range lines {
+		if line == nil {
+			continue
+		}
+		if cloned, ok := proto.Clone(line).(*feesv1.DerivedPostingLine); ok {
+			out = append(out, cloned)
+		}
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func cloneFeeRules(rules []*feesv1.AppliedRule) []*feesv1.AppliedRule {
+	if len(rules) == 0 {
+		return nil
+	}
+	out := make([]*feesv1.AppliedRule, 0, len(rules))
+	for _, rule := range rules {
+		if rule == nil {
+			continue
+		}
+		if cloned, ok := proto.Clone(rule).(*feesv1.AppliedRule); ok {
+			out = append(out, cloned)
+		}
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func extractFeeTotal(lines []*feesv1.DerivedPostingLine, currency string) *moneyv1.Money {
+	if len(lines) == 0 || currency == "" {
+		return nil
+	}
+	total := decimal.Zero
+	for _, line := range lines {
+		if line == nil || line.GetMoney() == nil {
+			continue
+		}
+		if !strings.EqualFold(line.GetMoney().GetCurrency(), currency) {
+			continue
+		}
+		amount, err := decimal.NewFromString(line.GetMoney().GetAmount())
+		if err != nil {
+			continue
+		}
+		switch line.GetSide() {
+		case accountingv1.EntrySide_ENTRY_SIDE_CREDIT:
+			total = total.Sub(amount.Abs())
+		default:
+			total = total.Add(amount.Abs())
+		}
+	}
+	if total.IsZero() {
+		return nil
+	}
+	return &moneyv1.Money{
+		Currency: currency,
+		Amount:   total.String(),
+	}
+}
+
+func computeAggregates(base, fee *moneyv1.Money, network *gatewayv1.EstimateTransferFeeResponse) (*moneyv1.Money, *moneyv1.Money) {
+	if base == nil {
+		return nil, nil
+	}
+	baseDecimal, err := decimalFromMoney(base)
+	if err != nil {
+		return cloneMoney(base), cloneMoney(base)
+	}
+	debit := baseDecimal
+	settlement := baseDecimal
+
+	if feeDecimal, err := decimalFromMoneyMatching(base, fee); err == nil && feeDecimal != nil {
+		debit = debit.Add(*feeDecimal)
+		settlement = settlement.Sub(*feeDecimal)
+	}
+
+	if network != nil && network.GetNetworkFee() != nil {
+		if networkDecimal, err := decimalFromMoneyMatching(base, network.GetNetworkFee()); err == nil && networkDecimal != nil {
+			debit = debit.Add(*networkDecimal)
+			settlement = settlement.Sub(*networkDecimal)
+		}
+	}
+
+	return makeMoney(base.GetCurrency(), debit), makeMoney(base.GetCurrency(), settlement)
+}
+
+func decimalFromMoney(m *moneyv1.Money) (decimal.Decimal, error) {
+	if m == nil {
+		return decimal.Zero, nil
+	}
+	return decimal.NewFromString(m.GetAmount())
+}
+
+func decimalFromMoneyMatching(reference, candidate *moneyv1.Money) (*decimal.Decimal, error) {
+	if reference == nil || candidate == nil {
+		return nil, nil
+	}
+	if !strings.EqualFold(reference.GetCurrency(), candidate.GetCurrency()) {
+		return nil, nil
+	}
+	value, err := decimal.NewFromString(candidate.GetAmount())
+	if err != nil {
+		return nil, err
+	}
+	return &value, nil
+}
+
+func makeMoney(currency string, value decimal.Decimal) *moneyv1.Money {
+	return &moneyv1.Money{
+		Currency: currency,
+		Amount:   value.String(),
+	}
+}
+
+func quoteToProto(src *oracleclient.Quote) *oraclev1.Quote {
+	if src == nil {
+		return nil
+	}
+	return &oraclev1.Quote{
+		QuoteRef:        src.QuoteRef,
+		Pair:            src.Pair,
+		Side:            src.Side,
+		Price:           &moneyv1.Decimal{Value: src.Price},
+		BaseAmount:      cloneMoney(src.BaseAmount),
+		QuoteAmount:     cloneMoney(src.QuoteAmount),
+		ExpiresAtUnixMs: src.ExpiresAt.UnixMilli(),
+		Provider:        src.Provider,
+		RateRef:         src.RateRef,
+		Firm:            src.Firm,
+	}
+}
+
+func ledgerChargesFromFeeLines(lines []*feesv1.DerivedPostingLine) []*ledgerv1.PostingLine {
+	if len(lines) == 0 {
+		return nil
+	}
+	charges := make([]*ledgerv1.PostingLine, 0, len(lines))
+	for _, line := range lines {
+		if line == nil || strings.TrimSpace(line.GetLedgerAccountRef()) == "" {
+			continue
+		}
+		money := cloneMoney(line.GetMoney())
+		if money == nil {
+			continue
+		}
+		charges = append(charges, &ledgerv1.PostingLine{
+			LedgerAccountRef: strings.TrimSpace(line.GetLedgerAccountRef()),
+			Money:            money,
+			LineType:         ledgerLineTypeFromAccounting(line.GetLineType()),
+		})
+	}
+	if len(charges) == 0 {
+		return nil
+	}
+	return charges
+}
+
+func ledgerLineTypeFromAccounting(lineType accountingv1.PostingLineType) ledgerv1.LineType {
+	switch lineType {
+	case accountingv1.PostingLineType_POSTING_LINE_SPREAD:
+		return ledgerv1.LineType_LINE_SPREAD
+	case accountingv1.PostingLineType_POSTING_LINE_REVERSAL:
+		return ledgerv1.LineType_LINE_REVERSAL
+	case accountingv1.PostingLineType_POSTING_LINE_FEE,
+		accountingv1.PostingLineType_POSTING_LINE_TAX:
+		return ledgerv1.LineType_LINE_FEE
+	default:
+		return ledgerv1.LineType_LINE_MAIN
+	}
+}
+
+func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*gatewayv1.ServiceFeeBreakdown {
+	if quote == nil {
+		return nil
+	}
+	lines := quote.GetFeeLines()
+	breakdown := make([]*gatewayv1.ServiceFeeBreakdown, 0, len(lines)+1)
+	for _, line := range lines {
+		if line == nil {
+			continue
+		}
+		amount := cloneMoney(line.GetMoney())
+		if amount == nil {
+			continue
+		}
+		code := strings.TrimSpace(line.GetMeta()["fee_code"])
+		if code == "" {
+			code = strings.TrimSpace(line.GetMeta()["fee_rule_id"])
+		}
+		if code == "" {
+			code = line.GetLineType().String()
+		}
+		desc := strings.TrimSpace(line.GetMeta()["description"])
+		breakdown = append(breakdown, &gatewayv1.ServiceFeeBreakdown{
+			FeeCode:     code,
+			Amount:      amount,
+			Description: desc,
+		})
+	}
+	if quote.GetNetworkFee() != nil && quote.GetNetworkFee().GetNetworkFee() != nil {
+		networkAmount := cloneMoney(quote.GetNetworkFee().GetNetworkFee())
+		if networkAmount != nil {
+			breakdown = append(breakdown, &gatewayv1.ServiceFeeBreakdown{
+				FeeCode:     "network_fee",
+				Amount:      networkAmount,
+				Description: strings.TrimSpace(quote.GetNetworkFee().GetEstimationContext()),
+			})
+		}
+	}
+	if len(breakdown) == 0 {
+		return nil
+	}
+	return breakdown
+}
+
+func moneyEquals(a, b *moneyv1.Money) bool {
+	if a == nil || b == nil {
+		return false
+	}
+	if !strings.EqualFold(a.GetCurrency(), b.GetCurrency()) {
+		return false
+	}
+	return strings.TrimSpace(a.GetAmount()) == strings.TrimSpace(b.GetAmount())
+}
+
+func conversionAmountFromMetadata(meta map[string]string, fx *orchestratorv1.FXIntent) (*moneyv1.Money, error) {
+	if meta == nil {
+		meta = map[string]string{}
+	}
+	amount := strings.TrimSpace(meta["amount"])
+	if amount == "" {
+		return nil, merrors.InvalidArgument("conversion amount metadata is required")
+	}
+	currency := strings.TrimSpace(meta["currency"])
+	if currency == "" && fx != nil && fx.GetPair() != nil {
+		currency = strings.TrimSpace(fx.GetPair().GetBase())
+	}
+	if currency == "" {
+		return nil, merrors.InvalidArgument("conversion currency metadata is required")
+	}
+	return &moneyv1.Money{
+		Currency: currency,
+		Amount:   amount,
+	}, nil
+}

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

@@ -0,0 +1,71 @@
+package orchestrator
+
+import (
+	"context"
+	"time"
+
+	"github.com/tech/sendico/pkg/api/routers/gsresponse"
+	"github.com/tech/sendico/pkg/mservice"
+	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+)
+
+func (s *Service) ensureRepository(ctx context.Context) error {
+	if s.storage == nil {
+		return errStorageUnavailable
+	}
+	return s.storage.Ping(ctx)
+}
+
+func (s *Service) withTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {
+	if d <= 0 {
+		return context.WithCancel(ctx)
+	}
+	return context.WithTimeout(ctx, d)
+}
+
+func executeUnary[TReq any, TResp any](ctx context.Context, svc *Service, method string, handler func(context.Context, *TReq) gsresponse.Responder[TResp], req *TReq) (*TResp, error) {
+	start := svc.clock.Now()
+	resp, err := gsresponse.Unary(svc.logger, mservice.PaymentOrchestrator, handler)(ctx, req)
+	observeRPC(method, err, svc.clock.Now().Sub(start))
+	return resp, err
+}
+
+func triggerFromKind(kind orchestratorv1.PaymentKind, requiresFX bool) feesv1.Trigger {
+	switch kind {
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_PAYOUT:
+		return feesv1.Trigger_TRIGGER_PAYOUT
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_INTERNAL_TRANSFER:
+		return feesv1.Trigger_TRIGGER_CAPTURE
+	case orchestratorv1.PaymentKind_PAYMENT_KIND_FX_CONVERSION:
+		return feesv1.Trigger_TRIGGER_FX_CONVERSION
+	default:
+		if requiresFX {
+			return feesv1.Trigger_TRIGGER_FX_CONVERSION
+		}
+		return feesv1.Trigger_TRIGGER_UNSPECIFIED
+	}
+}
+
+func shouldEstimateNetworkFee(intent *orchestratorv1.PaymentIntent) bool {
+	if intent == nil {
+		return false
+	}
+	if intent.GetKind() == orchestratorv1.PaymentKind_PAYMENT_KIND_PAYOUT {
+		return true
+	}
+	if intent.GetDestination().GetManagedWallet() != nil || intent.GetDestination().GetExternalChain() != nil {
+		return true
+	}
+	return false
+}
+
+func shouldRequestFX(intent *orchestratorv1.PaymentIntent) bool {
+	if intent == nil {
+		return false
+	}
+	if intent.GetRequiresFx() {
+		return true
+	}
+	return intent.GetFx() != nil && intent.GetFx().GetPair() != nil
+}

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

@@ -0,0 +1,65 @@
+package orchestrator
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/tech/sendico/pkg/merrors"
+)
+
+var (
+	metricsOnce sync.Once
+
+	rpcLatency *prometheus.HistogramVec
+	rpcStatus  *prometheus.CounterVec
+)
+
+func initMetrics() {
+	metricsOnce.Do(func() {
+		rpcLatency = promauto.NewHistogramVec(prometheus.HistogramOpts{
+			Namespace: "sendico",
+			Subsystem: "payment_orchestrator",
+			Name:      "rpc_latency_seconds",
+			Help:      "Latency distribution for payment orchestrator RPC handlers.",
+			Buckets:   prometheus.DefBuckets,
+		}, []string{"method"})
+
+		rpcStatus = promauto.NewCounterVec(prometheus.CounterOpts{
+			Namespace: "sendico",
+			Subsystem: "payment_orchestrator",
+			Name:      "rpc_requests_total",
+			Help:      "Total number of RPC invocations grouped by method and status.",
+		}, []string{"method", "status"})
+	})
+}
+
+func observeRPC(method string, err error, duration time.Duration) {
+	if rpcLatency != nil {
+		rpcLatency.WithLabelValues(method).Observe(duration.Seconds())
+	}
+	if rpcStatus != nil {
+		rpcStatus.WithLabelValues(method, statusLabel(err)).Inc()
+	}
+}
+
+func statusLabel(err error) string {
+	switch {
+	case err == nil:
+		return "ok"
+	case errors.Is(err, merrors.ErrInvalidArg):
+		return "invalid_argument"
+	case errors.Is(err, merrors.ErrNoData):
+		return "not_found"
+	case errors.Is(err, merrors.ErrDataConflict):
+		return "conflict"
+	case errors.Is(err, merrors.ErrAccessDenied):
+		return "denied"
+	case errors.Is(err, merrors.ErrInternal):
+		return "internal"
+	default:
+		return "error"
+	}
+}

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

@@ -0,0 +1,87 @@
+package orchestrator
+
+import (
+	"time"
+
+	chainclient "github.com/tech/sendico/chain/gateway/client"
+	oracleclient "github.com/tech/sendico/fx/oracle/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"
+)
+
+// Option configures service dependencies.
+type Option func(*Service)
+
+type feesDependency struct {
+	client  feesv1.FeeEngineClient
+	timeout time.Duration
+}
+
+func (f feesDependency) available() bool {
+	return f.client != nil
+}
+
+type ledgerDependency struct {
+	client ledgerclient.Client
+}
+
+func (l ledgerDependency) available() bool {
+	return l.client != nil
+}
+
+type gatewayDependency struct {
+	client chainclient.Client
+}
+
+func (g gatewayDependency) available() bool {
+	return g.client != nil
+}
+
+type oracleDependency struct {
+	client oracleclient.Client
+}
+
+func (o oracleDependency) available() bool {
+	return o.client != nil
+}
+
+// WithFeeEngine wires the fee engine client.
+func WithFeeEngine(client feesv1.FeeEngineClient, timeout time.Duration) Option {
+	return func(s *Service) {
+		s.fees = feesDependency{
+			client:  client,
+			timeout: timeout,
+		}
+	}
+}
+
+// WithLedgerClient wires the ledger client.
+func WithLedgerClient(client ledgerclient.Client) Option {
+	return func(s *Service) {
+		s.ledger = ledgerDependency{client: client}
+	}
+}
+
+// WithChainGatewayClient wires the chain gateway client.
+func WithChainGatewayClient(client chainclient.Client) Option {
+	return func(s *Service) {
+		s.gateway = gatewayDependency{client: client}
+	}
+}
+
+// WithOracleClient wires the FX oracle client.
+func WithOracleClient(client oracleclient.Client) Option {
+	return func(s *Service) {
+		s.oracle = oracleDependency{client: client}
+	}
+}
+
+// WithClock overrides the default clock.
+func WithClock(clock clockpkg.Clock) Option {
+	return func(s *Service) {
+		if clock != nil {
+			s.clock = clock
+		}
+	}
+}

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

@@ -0,0 +1,504 @@
+package orchestrator
+
+import (
+	"context"
+	"strings"
+
+	"github.com/tech/sendico/payments/orchestrator/storage"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/api/routers"
+	"github.com/tech/sendico/pkg/api/routers/gsresponse"
+	clockpkg "github.com/tech/sendico/pkg/clock"
+	"github.com/tech/sendico/pkg/merrors"
+	"github.com/tech/sendico/pkg/mlogger"
+	"github.com/tech/sendico/pkg/mservice"
+	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"google.golang.org/grpc"
+)
+
+type serviceError string
+
+func (e serviceError) Error() string {
+	return string(e)
+}
+
+const (
+	defaultFeeQuoteTTLMillis int64 = 120000
+	defaultOracleTTLMillis   int64 = 60000
+)
+
+var (
+	errStorageUnavailable = serviceError("payments.orchestrator: storage not initialised")
+)
+
+// Service orchestrates payments across ledger, billing, FX, and chain domains.
+type Service struct {
+	logger  mlogger.Logger
+	storage storage.Repository
+	clock   clockpkg.Clock
+
+	fees    feesDependency
+	ledger  ledgerDependency
+	gateway gatewayDependency
+	oracle  oracleDependency
+
+	orchestratorv1.UnimplementedPaymentOrchestratorServer
+}
+
+// NewService constructs a payment orchestrator service.
+func NewService(logger mlogger.Logger, repo storage.Repository, opts ...Option) *Service {
+	svc := &Service{
+		logger:  logger.Named("payment_orchestrator"),
+		storage: repo,
+		clock:   clockpkg.NewSystem(),
+	}
+
+	initMetrics()
+
+	for _, opt := range opts {
+		if opt != nil {
+			opt(svc)
+		}
+	}
+
+	if svc.clock == nil {
+		svc.clock = clockpkg.NewSystem()
+	}
+
+	return svc
+}
+
+// Register attaches the service to the supplied gRPC router.
+func (s *Service) Register(router routers.GRPC) error {
+	return router.Register(func(reg grpc.ServiceRegistrar) {
+		orchestratorv1.RegisterPaymentOrchestratorServer(reg, s)
+	})
+}
+
+// QuotePayment aggregates downstream quotes.
+func (s *Service) QuotePayment(ctx context.Context, req *orchestratorv1.QuotePaymentRequest) (*orchestratorv1.QuotePaymentResponse, error) {
+	return executeUnary(ctx, s, "QuotePayment", s.quotePaymentHandler, req)
+}
+
+// InitiatePayment captures a payment intent and reserves funds orchestration.
+func (s *Service) InitiatePayment(ctx context.Context, req *orchestratorv1.InitiatePaymentRequest) (*orchestratorv1.InitiatePaymentResponse, error) {
+	return executeUnary(ctx, s, "InitiatePayment", s.initiatePaymentHandler, req)
+}
+
+// CancelPayment attempts to cancel an in-flight payment.
+func (s *Service) CancelPayment(ctx context.Context, req *orchestratorv1.CancelPaymentRequest) (*orchestratorv1.CancelPaymentResponse, error) {
+	return executeUnary(ctx, s, "CancelPayment", s.cancelPaymentHandler, req)
+}
+
+// GetPayment returns a stored payment record.
+func (s *Service) GetPayment(ctx context.Context, req *orchestratorv1.GetPaymentRequest) (*orchestratorv1.GetPaymentResponse, error) {
+	return executeUnary(ctx, s, "GetPayment", s.getPaymentHandler, req)
+}
+
+// ListPayments lists stored payment records.
+func (s *Service) ListPayments(ctx context.Context, req *orchestratorv1.ListPaymentsRequest) (*orchestratorv1.ListPaymentsResponse, error) {
+	return executeUnary(ctx, s, "ListPayments", s.listPaymentsHandler, req)
+}
+
+// InitiateConversion orchestrates standalone FX conversions.
+func (s *Service) InitiateConversion(ctx context.Context, req *orchestratorv1.InitiateConversionRequest) (*orchestratorv1.InitiateConversionResponse, error) {
+	return executeUnary(ctx, s, "InitiateConversion", s.initiateConversionHandler, req)
+}
+
+// ProcessTransferUpdate reconciles chain events back into payment state.
+func (s *Service) ProcessTransferUpdate(ctx context.Context, req *orchestratorv1.ProcessTransferUpdateRequest) (*orchestratorv1.ProcessTransferUpdateResponse, error) {
+	return executeUnary(ctx, s, "ProcessTransferUpdate", s.processTransferUpdateHandler, req)
+}
+
+// ProcessDepositObserved reconciles deposit events to ledger.
+func (s *Service) ProcessDepositObserved(ctx context.Context, req *orchestratorv1.ProcessDepositObservedRequest) (*orchestratorv1.ProcessDepositObservedResponse, error) {
+	return executeUnary(ctx, s, "ProcessDepositObserved", s.processDepositObservedHandler, req)
+}
+
+func (s *Service) quotePaymentHandler(ctx context.Context, req *orchestratorv1.QuotePaymentRequest) gsresponse.Responder[orchestratorv1.QuotePaymentResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	meta := req.GetMeta()
+	if meta == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("meta is required"))
+	}
+	orgRef := strings.TrimSpace(meta.GetOrganizationRef())
+	if orgRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref is required"))
+	}
+	intent := req.GetIntent()
+	if intent == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent is required"))
+	}
+	if intent.GetAmount() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent.amount is required"))
+	}
+
+	quote, err := s.buildPaymentQuote(ctx, orgRef, req)
+	if err != nil {
+		return gsresponse.Auto[orchestratorv1.QuotePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	return gsresponse.Success(&orchestratorv1.QuotePaymentResponse{Quote: quote})
+}
+
+func (s *Service) initiatePaymentHandler(ctx context.Context, req *orchestratorv1.InitiatePaymentRequest) gsresponse.Responder[orchestratorv1.InitiatePaymentResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	meta := req.GetMeta()
+	if meta == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("meta is required"))
+	}
+	orgRef := strings.TrimSpace(meta.GetOrganizationRef())
+	if orgRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref is required"))
+	}
+	orgObjectID, parseErr := primitive.ObjectIDFromHex(orgRef)
+	if parseErr != nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref must be a valid objectID"))
+	}
+	intent := req.GetIntent()
+	if intent == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent is required"))
+	}
+	if intent.GetAmount() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("intent.amount is required"))
+	}
+	idempotencyKey := strings.TrimSpace(req.GetIdempotencyKey())
+	if idempotencyKey == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("idempotency_key is required"))
+	}
+
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+
+	existing, err := store.GetByIdempotencyKey(ctx, orgObjectID, idempotencyKey)
+	if err == nil && existing != nil {
+		return gsresponse.Success(&orchestratorv1.InitiatePaymentResponse{
+			Payment: toProtoPayment(existing),
+		})
+	}
+	if err != nil && err != storage.ErrPaymentNotFound {
+		return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	quote := req.GetFeeQuoteToken()
+	var quoteSnapshot *orchestratorv1.PaymentQuote
+	if quote == "" {
+		quoteSnapshot, err = s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
+			Meta:           req.GetMeta(),
+			IdempotencyKey: req.GetIdempotencyKey(),
+			Intent:         req.GetIntent(),
+			PreviewOnly:    false,
+		})
+		if err != nil {
+			return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+	} else {
+		quoteSnapshot = &orchestratorv1.PaymentQuote{FeeQuoteToken: quote}
+	}
+
+	entity := &model.Payment{}
+	entity.SetID(primitive.NewObjectID())
+	entity.SetOrganizationRef(orgObjectID)
+	entity.PaymentRef = entity.GetID().Hex()
+	entity.IdempotencyKey = idempotencyKey
+	entity.State = model.PaymentStateAccepted
+	entity.Intent = intentFromProto(intent)
+	entity.Metadata = cloneMetadata(req.GetMetadata())
+	entity.LastQuote = quoteSnapshotToModel(quoteSnapshot)
+	entity.Normalize()
+
+	if err = store.Create(ctx, entity); err != nil {
+		if err == storage.ErrDuplicatePayment {
+			return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.DataConflict("payment already exists"))
+		}
+		return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	if quoteSnapshot == nil {
+		quoteSnapshot = &orchestratorv1.PaymentQuote{}
+	}
+
+	if err := s.executePayment(ctx, store, entity, quoteSnapshot); err != nil {
+		return gsresponse.Auto[orchestratorv1.InitiatePaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	return gsresponse.Success(&orchestratorv1.InitiatePaymentResponse{
+		Payment: toProtoPayment(entity),
+	})
+}
+
+func (s *Service) cancelPaymentHandler(ctx context.Context, req *orchestratorv1.CancelPaymentRequest) gsresponse.Responder[orchestratorv1.CancelPaymentResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	paymentRef := strings.TrimSpace(req.GetPaymentRef())
+	if paymentRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("payment_ref is required"))
+	}
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+	payment, err := store.GetByPaymentRef(ctx, paymentRef)
+	if err != nil {
+		if err == storage.ErrPaymentNotFound {
+			return gsresponse.NotFound[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+		return gsresponse.Auto[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if payment.State != model.PaymentStateAccepted {
+		reason := merrors.InvalidArgument("payment cannot be cancelled in current state")
+		return gsresponse.FailedPrecondition[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, "payment_not_cancellable", reason)
+	}
+	payment.State = model.PaymentStateCancelled
+	payment.FailureCode = model.PaymentFailureCodePolicy
+	payment.FailureReason = strings.TrimSpace(req.GetReason())
+	if err := store.Update(ctx, payment); err != nil {
+		return gsresponse.Auto[orchestratorv1.CancelPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	return gsresponse.Success(&orchestratorv1.CancelPaymentResponse{Payment: toProtoPayment(payment)})
+}
+
+func (s *Service) getPaymentHandler(ctx context.Context, req *orchestratorv1.GetPaymentRequest) gsresponse.Responder[orchestratorv1.GetPaymentResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	paymentRef := strings.TrimSpace(req.GetPaymentRef())
+	if paymentRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("payment_ref is required"))
+	}
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+	entity, err := store.GetByPaymentRef(ctx, paymentRef)
+	if err != nil {
+		if err == storage.ErrPaymentNotFound {
+			return gsresponse.NotFound[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+		return gsresponse.Auto[orchestratorv1.GetPaymentResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	return gsresponse.Success(&orchestratorv1.GetPaymentResponse{Payment: toProtoPayment(entity)})
+}
+
+func (s *Service) listPaymentsHandler(ctx context.Context, req *orchestratorv1.ListPaymentsRequest) gsresponse.Responder[orchestratorv1.ListPaymentsResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.ListPaymentsResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.ListPaymentsResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.ListPaymentsResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+	filter := filterFromProto(req)
+	result, err := store.List(ctx, filter)
+	if err != nil {
+		return gsresponse.Auto[orchestratorv1.ListPaymentsResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	resp := &orchestratorv1.ListPaymentsResponse{
+		Page: &paginationv1.CursorPageResponse{
+			NextCursor: result.NextCursor,
+		},
+	}
+	resp.Payments = make([]*orchestratorv1.Payment, 0, len(result.Items))
+	for _, item := range result.Items {
+		resp.Payments = append(resp.Payments, toProtoPayment(item))
+	}
+	return gsresponse.Success(resp)
+}
+
+func (s *Service) initiateConversionHandler(ctx context.Context, req *orchestratorv1.InitiateConversionRequest) gsresponse.Responder[orchestratorv1.InitiateConversionResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("nil request"))
+	}
+	meta := req.GetMeta()
+	if meta == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("meta is required"))
+	}
+	orgRef := strings.TrimSpace(meta.GetOrganizationRef())
+	if orgRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref is required"))
+	}
+	orgObjectID, parseErr := primitive.ObjectIDFromHex(orgRef)
+	if parseErr != nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("organization_ref must be a valid objectID"))
+	}
+	idempotencyKey := strings.TrimSpace(req.GetIdempotencyKey())
+	if idempotencyKey == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("idempotency_key is required"))
+	}
+	if req.GetSource() == nil || req.GetSource().GetLedger() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("source ledger endpoint is required"))
+	}
+	if req.GetDestination() == nil || req.GetDestination().GetLedger() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("destination ledger endpoint is required"))
+	}
+	fxIntent := req.GetFx()
+	if fxIntent == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("fx intent is required"))
+	}
+
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+
+	if existing, err := store.GetByIdempotencyKey(ctx, orgObjectID, idempotencyKey); err == nil && existing != nil {
+		return gsresponse.Success(&orchestratorv1.InitiateConversionResponse{Conversion: toProtoPayment(existing)})
+	} else if err != nil && err != storage.ErrPaymentNotFound {
+		return gsresponse.Auto[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	amount, err := conversionAmountFromMetadata(req.GetMetadata(), fxIntent)
+	if err != nil {
+		return gsresponse.InvalidArgument[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	intentProto := &orchestratorv1.PaymentIntent{
+		Kind:        orchestratorv1.PaymentKind_PAYMENT_KIND_FX_CONVERSION,
+		Source:      req.GetSource(),
+		Destination: req.GetDestination(),
+		Amount:      amount,
+		RequiresFx:  true,
+		Fx:          fxIntent,
+		FeePolicy:   req.GetFeePolicy(),
+	}
+
+	quote, err := s.buildPaymentQuote(ctx, orgRef, &orchestratorv1.QuotePaymentRequest{
+		Meta:           req.GetMeta(),
+		IdempotencyKey: req.GetIdempotencyKey(),
+		Intent:         intentProto,
+	})
+	if err != nil {
+		return gsresponse.Auto[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	entity := &model.Payment{}
+	entity.SetID(primitive.NewObjectID())
+	entity.SetOrganizationRef(orgObjectID)
+	entity.PaymentRef = entity.GetID().Hex()
+	entity.IdempotencyKey = idempotencyKey
+	entity.State = model.PaymentStateAccepted
+	entity.Intent = intentFromProto(intentProto)
+	entity.Metadata = cloneMetadata(req.GetMetadata())
+	entity.LastQuote = quoteSnapshotToModel(quote)
+	entity.Normalize()
+
+	if err = store.Create(ctx, entity); err != nil {
+		if err == storage.ErrDuplicatePayment {
+			return gsresponse.Auto[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, merrors.DataConflict("payment already exists"))
+		}
+		return gsresponse.Auto[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	if err := s.executePayment(ctx, store, entity, quote); err != nil {
+		return gsresponse.Auto[orchestratorv1.InitiateConversionResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+
+	return gsresponse.Success(&orchestratorv1.InitiateConversionResponse{
+		Conversion: toProtoPayment(entity),
+	})
+}
+
+func (s *Service) processTransferUpdateHandler(ctx context.Context, req *orchestratorv1.ProcessTransferUpdateRequest) gsresponse.Responder[orchestratorv1.ProcessTransferUpdateResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil || req.GetEvent() == nil || req.GetEvent().GetTransfer() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("transfer event is required"))
+	}
+	transfer := req.GetEvent().GetTransfer()
+	transferRef := strings.TrimSpace(transfer.GetTransferRef())
+	if transferRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("transfer_ref is required"))
+	}
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+	payment, err := store.GetByChainTransferRef(ctx, transferRef)
+	if err != nil {
+		if err == storage.ErrPaymentNotFound {
+			return gsresponse.NotFound[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+		return gsresponse.Auto[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	applyTransferStatus(req.GetEvent(), payment)
+	if err := store.Update(ctx, payment); err != nil {
+		return gsresponse.Auto[orchestratorv1.ProcessTransferUpdateResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	return gsresponse.Success(&orchestratorv1.ProcessTransferUpdateResponse{Payment: toProtoPayment(payment)})
+}
+
+func (s *Service) processDepositObservedHandler(ctx context.Context, req *orchestratorv1.ProcessDepositObservedRequest) gsresponse.Responder[orchestratorv1.ProcessDepositObservedResponse] {
+	if err := s.ensureRepository(ctx); err != nil {
+		return gsresponse.Unavailable[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	if req == nil || req.GetEvent() == nil {
+		return gsresponse.InvalidArgument[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("deposit event is required"))
+	}
+	event := req.GetEvent()
+	walletRef := strings.TrimSpace(event.GetWalletRef())
+	if walletRef == "" {
+		return gsresponse.InvalidArgument[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, merrors.InvalidArgument("wallet_ref is required"))
+	}
+	store := s.storage.Payments()
+	if store == nil {
+		return gsresponse.Unavailable[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, errStorageUnavailable)
+	}
+	filter := &model.PaymentFilter{
+		States:         []model.PaymentState{model.PaymentStateSubmitted, model.PaymentStateFundsReserved},
+		DestinationRef: walletRef,
+	}
+	result, err := store.List(ctx, filter)
+	if err != nil {
+		return gsresponse.Auto[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, err)
+	}
+	for _, payment := range result.Items {
+		if payment.Intent.Destination.Type != model.EndpointTypeManagedWallet {
+			continue
+		}
+		if !moneyEquals(payment.Intent.Amount, event.GetAmount()) {
+			continue
+		}
+		payment.State = model.PaymentStateSettled
+		payment.FailureCode = model.PaymentFailureCodeUnspecified
+		payment.FailureReason = ""
+		if payment.Execution == nil {
+			payment.Execution = &model.ExecutionRefs{}
+		}
+		if payment.Execution.ChainTransferRef == "" {
+			payment.Execution.ChainTransferRef = strings.TrimSpace(event.GetTransactionHash())
+		}
+		if err := store.Update(ctx, payment); err != nil {
+			return gsresponse.Auto[orchestratorv1.ProcessDepositObservedResponse](s.logger, mservice.PaymentOrchestrator, err)
+		}
+		return gsresponse.Success(&orchestratorv1.ProcessDepositObservedResponse{Payment: toProtoPayment(payment)})
+	}
+	return gsresponse.Success(&orchestratorv1.ProcessDepositObservedResponse{})
+}

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

@@ -0,0 +1,290 @@
+package orchestrator
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	chainclient "github.com/tech/sendico/chain/gateway/client"
+	ledgerclient "github.com/tech/sendico/ledger/client"
+	"github.com/tech/sendico/payments/orchestrator/storage"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/api/routers/gsresponse"
+	mo "github.com/tech/sendico/pkg/model"
+	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
+	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
+	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.uber.org/zap"
+)
+
+func TestExecutePayment_FXConversionSettled(t *testing.T) {
+	ctx := context.Background()
+
+	store := newStubPaymentsStore()
+	repo := &stubRepository{store: store}
+	svc := &Service{
+		logger:  zap.NewNop(),
+		clock:   testClock{now: time.Now()},
+		storage: repo,
+		ledger: ledgerDependency{client: &ledgerclient.Fake{
+			ApplyFXWithChargesFn: func(ctx context.Context, req *ledgerv1.FXRequest) (*ledgerv1.PostResponse, error) {
+				return &ledgerv1.PostResponse{JournalEntryRef: "fx-entry"}, nil
+			},
+		}},
+	}
+
+	payment := &model.Payment{
+		PaymentRef:            "fx-1",
+		IdempotencyKey:        "fx-1",
+		OrganizationBoundBase: mo.OrganizationBoundBase{OrganizationRef: primitive.NewObjectID()},
+		Intent: model.PaymentIntent{
+			Kind: model.PaymentKindFXConversion,
+			Source: model.PaymentEndpoint{
+				Type:   model.EndpointTypeLedger,
+				Ledger: &model.LedgerEndpoint{LedgerAccountRef: "ledger:source"},
+			},
+			Destination: model.PaymentEndpoint{
+				Type:   model.EndpointTypeLedger,
+				Ledger: &model.LedgerEndpoint{LedgerAccountRef: "ledger:dest"},
+			},
+			Amount: &moneyv1.Money{Currency: "USD", Amount: "100"},
+		},
+	}
+	store.payments[payment.PaymentRef] = payment
+
+	quote := &orchestratorv1.PaymentQuote{
+		FxQuote: &oraclev1.Quote{
+			QuoteRef:    "quote-1",
+			BaseAmount:  &moneyv1.Money{Currency: "USD", Amount: "100"},
+			QuoteAmount: &moneyv1.Money{Currency: "EUR", Amount: "90"},
+			Price:       &moneyv1.Decimal{Value: "0.9"},
+		},
+	}
+
+	if err := svc.executePayment(ctx, store, payment, quote); err != nil {
+		t.Fatalf("executePayment returned error: %v", err)
+	}
+
+	if payment.State != model.PaymentStateSettled {
+		t.Fatalf("expected payment settled, got %s", payment.State)
+	}
+	if payment.Execution == nil || payment.Execution.FXEntryRef == "" {
+		t.Fatal("expected FX entry ref set on payment execution")
+	}
+}
+
+func TestExecutePayment_ChainFailure(t *testing.T) {
+	ctx := context.Background()
+
+	store := newStubPaymentsStore()
+	repo := &stubRepository{store: store}
+	svc := &Service{
+		logger:  zap.NewNop(),
+		clock:   testClock{now: time.Now()},
+		storage: repo,
+		gateway: gatewayDependency{client: &chainclient.Fake{
+			SubmitTransferFn: func(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error) {
+				return nil, errors.New("chain failure")
+			},
+		}},
+	}
+
+	payment := &model.Payment{
+		PaymentRef:            "chain-1",
+		IdempotencyKey:        "chain-1",
+		OrganizationBoundBase: mo.OrganizationBoundBase{OrganizationRef: primitive.NewObjectID()},
+		Intent: model.PaymentIntent{
+			Kind: model.PaymentKindPayout,
+			Source: model.PaymentEndpoint{
+				Type: model.EndpointTypeManagedWallet,
+				ManagedWallet: &model.ManagedWalletEndpoint{
+					ManagedWalletRef: "wallet-src",
+				},
+			},
+			Destination: model.PaymentEndpoint{
+				Type: model.EndpointTypeManagedWallet,
+				ManagedWallet: &model.ManagedWalletEndpoint{
+					ManagedWalletRef: "wallet-dst",
+				},
+			},
+			Amount: &moneyv1.Money{Currency: "USD", Amount: "50"},
+		},
+	}
+	store.payments[payment.PaymentRef] = payment
+
+	err := svc.executePayment(ctx, store, payment, &orchestratorv1.PaymentQuote{})
+	if err == nil || err.Error() != "chain failure" {
+		t.Fatalf("expected chain failure error, got %v", err)
+	}
+	if payment.State != model.PaymentStateFailed {
+		t.Fatalf("expected payment failed, got %s", payment.State)
+	}
+	if payment.FailureCode != model.PaymentFailureCodeChain {
+		t.Fatalf("expected failure code chain, got %s", payment.FailureCode)
+	}
+}
+
+func TestProcessTransferUpdateHandler_Settled(t *testing.T) {
+	ctx := context.Background()
+	payment := &model.Payment{
+		PaymentRef: "pay-1",
+		State:      model.PaymentStateSubmitted,
+		Execution:  &model.ExecutionRefs{ChainTransferRef: "transfer-1"},
+	}
+	store := newStubPaymentsStore()
+	store.payments[payment.PaymentRef] = payment
+	store.byChain["transfer-1"] = payment
+
+	svc := &Service{
+		logger:  zap.NewNop(),
+		clock:   testClock{now: time.Now()},
+		storage: &stubRepository{store: store},
+	}
+
+	req := &orchestratorv1.ProcessTransferUpdateRequest{
+		Event: &gatewayv1.TransferStatusChangedEvent{
+			Transfer: &gatewayv1.Transfer{
+				TransferRef: "transfer-1",
+				Status:      gatewayv1.TransferStatus_TRANSFER_CONFIRMED,
+			},
+		},
+	}
+
+	reSP, err := gsresponse.Execute(ctx, svc.processTransferUpdateHandler(ctx, req))
+	if err != nil {
+		t.Fatalf("handler returned error: %v", err)
+	}
+	if reSP.GetPayment().GetState() != orchestratorv1.PaymentState_PAYMENT_STATE_SETTLED {
+		t.Fatalf("expected settled state, got %s", reSP.GetPayment().GetState())
+	}
+}
+
+func TestProcessDepositObservedHandler_MatchesPayment(t *testing.T) {
+	ctx := context.Background()
+	payment := &model.Payment{
+		PaymentRef: "pay-2",
+		State:      model.PaymentStateSubmitted,
+		Intent: model.PaymentIntent{
+			Destination: model.PaymentEndpoint{
+				Type: model.EndpointTypeManagedWallet,
+				ManagedWallet: &model.ManagedWalletEndpoint{
+					ManagedWalletRef: "wallet-dst",
+				},
+			},
+			Amount: &moneyv1.Money{Currency: "USD", Amount: "40"},
+		},
+	}
+	store := newStubPaymentsStore()
+	store.listResp = &model.PaymentList{Items: []*model.Payment{payment}}
+	store.payments[payment.PaymentRef] = payment
+
+	svc := &Service{
+		logger:  zap.NewNop(),
+		clock:   testClock{now: time.Now()},
+		storage: &stubRepository{store: store},
+	}
+
+	req := &orchestratorv1.ProcessDepositObservedRequest{
+		Event: &gatewayv1.WalletDepositObservedEvent{
+			WalletRef: "wallet-dst",
+			Amount:    &moneyv1.Money{Currency: "USD", Amount: "40"},
+		},
+	}
+
+	reSP, err := gsresponse.Execute(ctx, svc.processDepositObservedHandler(ctx, req))
+	if err != nil {
+		t.Fatalf("handler returned error: %v", err)
+	}
+	if reSP.GetPayment().GetState() != orchestratorv1.PaymentState_PAYMENT_STATE_SETTLED {
+		t.Fatalf("expected settled state, got %s", reSP.GetPayment().GetState())
+	}
+}
+
+// ----------------------------------------------------------------------
+
+type stubRepository struct {
+	store *stubPaymentsStore
+}
+
+func (r *stubRepository) Ping(context.Context) error      { return nil }
+func (r *stubRepository) Payments() storage.PaymentsStore { return r.store }
+
+type stubPaymentsStore struct {
+	payments map[string]*model.Payment
+	byChain  map[string]*model.Payment
+	listResp *model.PaymentList
+}
+
+func newStubPaymentsStore() *stubPaymentsStore {
+	return &stubPaymentsStore{
+		payments: map[string]*model.Payment{},
+		byChain:  map[string]*model.Payment{},
+	}
+}
+
+func (s *stubPaymentsStore) Create(ctx context.Context, payment *model.Payment) error {
+	if _, exists := s.payments[payment.PaymentRef]; exists {
+		return storage.ErrDuplicatePayment
+	}
+	s.payments[payment.PaymentRef] = payment
+	if payment.Execution != nil && payment.Execution.ChainTransferRef != "" {
+		s.byChain[payment.Execution.ChainTransferRef] = payment
+	}
+	return nil
+}
+
+func (s *stubPaymentsStore) Update(ctx context.Context, payment *model.Payment) error {
+	if _, exists := s.payments[payment.PaymentRef]; !exists {
+		return storage.ErrPaymentNotFound
+	}
+	s.payments[payment.PaymentRef] = payment
+	if payment.Execution != nil && payment.Execution.ChainTransferRef != "" {
+		s.byChain[payment.Execution.ChainTransferRef] = payment
+	}
+	return nil
+}
+
+func (s *stubPaymentsStore) GetByPaymentRef(ctx context.Context, paymentRef string) (*model.Payment, error) {
+	if p, ok := s.payments[paymentRef]; ok {
+		return p, nil
+	}
+	return nil, storage.ErrPaymentNotFound
+}
+
+func (s *stubPaymentsStore) GetByIdempotencyKey(ctx context.Context, orgRef primitive.ObjectID, key string) (*model.Payment, error) {
+	for _, p := range s.payments {
+		if p.OrganizationRef == orgRef && strings.TrimSpace(p.IdempotencyKey) == key {
+			return p, nil
+		}
+	}
+	return nil, storage.ErrPaymentNotFound
+}
+
+func (s *stubPaymentsStore) GetByChainTransferRef(ctx context.Context, transferRef string) (*model.Payment, error) {
+	if p, ok := s.byChain[transferRef]; ok {
+		return p, nil
+	}
+	return nil, storage.ErrPaymentNotFound
+}
+
+func (s *stubPaymentsStore) List(ctx context.Context, filter *model.PaymentFilter) (*model.PaymentList, error) {
+	if s.listResp != nil {
+		return s.listResp, nil
+	}
+	return &model.PaymentList{}, nil
+}
+
+var _ storage.PaymentsStore = (*stubPaymentsStore)(nil)
+
+// testClock satisfies clock.Clock
+
+type testClock struct {
+	now time.Time
+}
+
+func (c testClock) Now() time.Time { return c.now }