improved ledger account discovery

api/payments/orchestrator/internal/server/internal/config.go

@@ -22,6 +22,7 @@ type config struct {
 	CardGateways     map[string]cardGatewayRouteConfig `yaml:"card_gateways"`
 	FeeAccounts      map[string]string                 `yaml:"fee_ledger_accounts"`
 	GatewayInstances []gatewayInstanceConfig           `yaml:"gateway_instances"`
+	QuoteRetentionHrs int                              `yaml:"quote_retention_hours"`
 }
 
 type clientConfig struct {
@@ -84,6 +85,13 @@ func (c clientConfig) callTimeout() time.Duration {
 	return time.Duration(c.CallTimeoutSecs) * time.Second
 }
 
+func (c *config) quoteRetention() time.Duration {
+	if c == nil || c.QuoteRetentionHrs <= 0 {
+		return 72 * time.Hour
+	}
+	return time.Duration(c.QuoteRetentionHrs) * time.Hour
+}
+
 func (i *Imp) loadConfig() (*config, error) {
 	data, err := os.ReadFile(i.file)
 	if err != nil {

api/payments/orchestrator/internal/server/internal/discovery_wrappers.go

@@ -9,6 +9,7 @@ import (
 	"github.com/tech/sendico/pkg/payments/rail"
 	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	connectorv1 "github.com/tech/sendico/pkg/proto/connector/v1"
 	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	mntxv1 "github.com/tech/sendico/pkg/proto/gateway/mntx/v1"
 	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
@@ -109,6 +110,14 @@ func (c *discoveryLedgerClient) ListAccounts(ctx context.Context, req *ledgerv1.
 	return client.ListAccounts(ctx, req)
 }
 
+func (c *discoveryLedgerClient) ListConnectorAccounts(ctx context.Context, req *connectorv1.ListAccountsRequest) (*connectorv1.ListAccountsResponse, error) {
+	client, err := c.resolver.LedgerClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return client.ListConnectorAccounts(ctx, req)
+}
+
 func (c *discoveryLedgerClient) PostCreditWithCharges(ctx context.Context, req *ledgerv1.PostCreditRequest) (*ledgerv1.PostResponse, error) {
 	client, err := c.resolver.LedgerClient(ctx)
 	if err != nil {

api/payments/orchestrator/internal/server/internal/serverimp.go

@@ -38,8 +38,9 @@ func (i *Imp) Start() error {
 
 	i.initDiscovery(cfg)
 
+	quoteRetention := cfg.quoteRetention()
 	repoFactory := func(logger mlogger.Logger, conn *db.MongoConnection) (storage.Repository, error) {
-		return mongostorage.New(logger, conn)
+		return mongostorage.New(logger, conn, mongostorage.WithQuoteRetention(quoteRetention))
 	}
 
 	var broker mb.Broker

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

@@ -122,7 +122,7 @@ func (h *quotePaymentCommand) quotePayment(
 		return quote, nil
 	}
 
-	existing, err := quotesStore.GetByIdempotencyKey(ctx, qc.idempotencyKey)
+	existing, err := quotesStore.GetByIdempotencyKey(ctx, qc.orgRef, qc.idempotencyKey)
 	if err != nil && !errors.Is(err, storage.ErrQuoteNotFound) {
 		h.logger.Warn(
 			"Failed to lookup quote by idempotency key",
@@ -172,7 +172,7 @@ func (h *quotePaymentCommand) quotePayment(
 
 	if err := quotesStore.Create(ctx, record); err != nil {
 		if errors.Is(err, storage.ErrDuplicateQuote) {
-			existing, getErr := quotesStore.GetByIdempotencyKey(ctx, qc.idempotencyKey)
+			existing, getErr := quotesStore.GetByIdempotencyKey(ctx, qc.orgRef, qc.idempotencyKey)
 			if getErr == nil && existing != nil {
 				if existing.Hash != qc.hash {
 					return nil, errIdempotencyParamMismatch
@@ -372,7 +372,7 @@ func (h *quotePaymentsCommand) tryReuse(
 	qc *quotePaymentsCtx,
 ) (*model.PaymentQuoteRecord, bool, error) {
 
-	rec, err := quotesStore.GetByIdempotencyKey(ctx, qc.idempotencyKey)
+	rec, err := quotesStore.GetByIdempotencyKey(ctx, qc.orgRef, qc.idempotencyKey)
 	if err != nil {
 		if errors.Is(err, storage.ErrQuoteNotFound) {
 			return nil, false, nil

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

@@ -8,6 +8,7 @@ import (
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/payments/rail"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	connectorv1 "github.com/tech/sendico/pkg/proto/connector/v1"
 	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
 	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -23,7 +24,7 @@ func (p *paymentExecutor) postLedgerDebit(ctx context.Context, payment *model.Pa
 		p.logger.Error("Ledger client unavailable", zap.String("action", "debit"), zap.String("payment_ref", paymentRef))
 		return "", merrors.Internal("ledger_client_unavailable")
 	}
-	tx, err := p.ledgerTxForAction(payment, amount, charges, idempotencyKey, idx, model.RailOperationDebit, quote)
+	tx, err := p.ledgerTxForAction(ctx, payment, amount, charges, idempotencyKey, idx, model.RailOperationDebit, quote)
 	if err != nil {
 		p.logger.Warn("Ledger debit preparation failed", zap.String("payment_ref", paymentRef), zap.Int("step_index", idx), zap.Error(err))
 		return "", err
@@ -45,7 +46,7 @@ func (p *paymentExecutor) postLedgerCredit(ctx context.Context, payment *model.P
 		p.logger.Error("Ledger client unavailable", zap.String("action", "credit"), zap.String("payment_ref", paymentRef))
 		return "", merrors.Internal("ledger_client_unavailable")
 	}
-	tx, err := p.ledgerTxForAction(payment, amount, nil, idempotencyKey, idx, model.RailOperationCredit, quote)
+	tx, err := p.ledgerTxForAction(ctx, payment, amount, nil, idempotencyKey, idx, model.RailOperationCredit, quote)
 	if err != nil {
 		p.logger.Warn("Ledger credit preparation failed", zap.String("payment_ref", paymentRef), zap.Int("step_index", idx), zap.Error(err))
 		return "", err
@@ -174,7 +175,7 @@ func (p *paymentExecutor) postLedgerRelease(ctx context.Context, payment *model.
 	return entryRef, nil
 }
 
-func (p *paymentExecutor) ledgerTxForAction(payment *model.Payment, amount *moneyv1.Money, charges []*ledgerv1.PostingLine, idempotencyKey string, idx int, action model.RailOperation, quote *orchestratorv1.PaymentQuote) (rail.LedgerTx, error) {
+func (p *paymentExecutor) ledgerTxForAction(ctx context.Context, payment *model.Payment, amount *moneyv1.Money, charges []*ledgerv1.PostingLine, idempotencyKey string, idx int, action model.RailOperation, quote *orchestratorv1.PaymentQuote) (rail.LedgerTx, error) {
 	if payment == nil {
 		return rail.LedgerTx{}, merrors.InvalidArgument("ledger: payment is required")
 	}
@@ -205,6 +206,9 @@ func (p *paymentExecutor) ledgerTxForAction(payment *model.Payment, amount *mone
 		fromRail = model.RailLedger
 		toRail = ledgerStepToRail(payment.PaymentPlan, idx, destRail)
 		accountRef, contraRef, err = ledgerDebitAccount(payment)
+		if err != nil {
+			accountRef, contraRef, err = p.resolveLedgerAccountRef(ctx, payment, amount, action)
+		}
 		if err == nil {
 			if blockRef := ledgerBlockAccountIfConfirmed(payment); blockRef != "" {
 				accountRef = blockRef
@@ -215,6 +219,9 @@ func (p *paymentExecutor) ledgerTxForAction(payment *model.Payment, amount *mone
 		fromRail = ledgerStepFromRail(payment.PaymentPlan, idx, sourceRail)
 		toRail = model.RailLedger
 		accountRef, contraRef, err = ledgerCreditAccount(payment)
+		if err != nil {
+			accountRef, contraRef, err = p.resolveLedgerAccountRef(ctx, payment, amount, action)
+		}
 		externalRef = ledgerExternalReference(payment.ExecutionPlan, idx)
 	default:
 		return rail.LedgerTx{}, merrors.InvalidArgument("ledger: unsupported action")
@@ -321,6 +328,116 @@ func ledgerExternalReference(plan *model.ExecutionPlan, idx int) string {
 	return ""
 }
 
+func (p *paymentExecutor) resolveLedgerAccountRef(ctx context.Context, payment *model.Payment, amount *moneyv1.Money, action model.RailOperation) (string, string, error) {
+	if payment == nil {
+		return "", "", merrors.InvalidArgument("ledger: payment is required")
+	}
+	if amount == nil || strings.TrimSpace(amount.GetCurrency()) == "" {
+		return "", "", merrors.InvalidArgument("ledger: amount is required")
+	}
+	switch action {
+	case model.RailOperationCredit:
+		if account, _, err := ledgerDebitAccount(payment); err == nil && strings.TrimSpace(account) != "" {
+			setLedgerAccountAttributes(payment, account)
+			return account, "", nil
+		}
+	case model.RailOperationDebit:
+		if account, _, err := ledgerCreditAccount(payment); err == nil && strings.TrimSpace(account) != "" {
+			setLedgerAccountAttributes(payment, account)
+			return account, "", nil
+		}
+	}
+	account, err := p.resolveOrgOwnedLedgerAccount(ctx, payment, amount)
+	if err != nil {
+		return "", "", err
+	}
+	setLedgerAccountAttributes(payment, account)
+	return account, "", nil
+}
+
+func (p *paymentExecutor) resolveOrgOwnedLedgerAccount(ctx context.Context, payment *model.Payment, amount *moneyv1.Money) (string, error) {
+	if payment == nil {
+		return "", merrors.InvalidArgument("ledger: payment is required")
+	}
+	if payment.OrganizationRef == primitive.NilObjectID {
+		return "", merrors.InvalidArgument("ledger: organization_ref is required")
+	}
+	if amount == nil || strings.TrimSpace(amount.GetCurrency()) == "" {
+		return "", merrors.InvalidArgument("ledger: amount is required")
+	}
+	if p == nil || p.deps == nil || p.deps.ledger.client == nil {
+		return "", merrors.Internal("ledger_client_unavailable")
+	}
+
+	currency := strings.TrimSpace(amount.GetCurrency())
+	resp, err := p.deps.ledger.client.ListConnectorAccounts(ctx, &connectorv1.ListAccountsRequest{
+		OrganizationRef: payment.OrganizationRef.Hex(),
+		Kind:            connectorv1.AccountKind_LEDGER_ACCOUNT,
+		Asset:           currency,
+	})
+	if err != nil {
+		return "", err
+	}
+	for _, account := range resp.GetAccounts() {
+		if account == nil {
+			continue
+		}
+		if account.GetKind() != connectorv1.AccountKind_LEDGER_ACCOUNT {
+			continue
+		}
+		asset := strings.TrimSpace(account.GetAsset())
+		if asset == "" || !strings.EqualFold(asset, currency) {
+			continue
+		}
+		if strings.TrimSpace(account.GetOwnerRef()) != "" {
+			continue
+		}
+		if connectorAccountIsSettlement(account) {
+			continue
+		}
+		if ref := account.GetRef(); ref != nil {
+			if accountID := strings.TrimSpace(ref.GetAccountId()); accountID != "" {
+				return accountID, nil
+			}
+		}
+	}
+	return "", merrors.InvalidArgument("ledger: org-owned account not found")
+}
+
+func connectorAccountIsSettlement(account *connectorv1.Account) bool {
+	if account == nil || account.GetProviderDetails() == nil {
+		return false
+	}
+	details := account.GetProviderDetails().AsMap()
+	val, ok := details["is_settlement"]
+	if !ok {
+		return false
+	}
+	switch v := val.(type) {
+	case bool:
+		return v
+	case string:
+		return strings.EqualFold(strings.TrimSpace(v), "true")
+	default:
+		return false
+	}
+}
+
+func setLedgerAccountAttributes(payment *model.Payment, accountRef string) {
+	if payment == nil || strings.TrimSpace(accountRef) == "" {
+		return
+	}
+	if payment.Intent.Attributes == nil {
+		payment.Intent.Attributes = map[string]string{}
+	}
+	if attributeLookup(payment.Intent.Attributes, "ledger_debit_account_ref", "ledgerDebitAccountRef") == "" {
+		payment.Intent.Attributes["ledger_debit_account_ref"] = accountRef
+	}
+	if attributeLookup(payment.Intent.Attributes, "ledger_credit_account_ref", "ledgerCreditAccountRef") == "" {
+		payment.Intent.Attributes["ledger_credit_account_ref"] = accountRef
+	}
+}
+
 func ledgerDebitAccount(payment *model.Payment) (string, string, error) {
 	if payment == nil {
 		return "", "", merrors.InvalidArgument("ledger: payment is required")

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

@@ -0,0 +1,96 @@
+package orchestrator
+
+import (
+	"context"
+	"testing"
+
+	ledgerclient "github.com/tech/sendico/ledger/client"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/payments/rail"
+	paymenttypes "github.com/tech/sendico/pkg/payments/types"
+	connectorv1 "github.com/tech/sendico/pkg/proto/connector/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/structpb"
+)
+
+func TestLedgerAccountResolution_UsesOrgOwnedAccount(t *testing.T) {
+	ctx := context.Background()
+	accountID := "ledger:org:usd"
+
+	providerDetails, err := structpb.NewStruct(map[string]interface{}{
+		"is_settlement": false,
+	})
+	if err != nil {
+		t.Fatalf("provider details build error: %v", err)
+	}
+
+	listCalls := 0
+	ledgerAccountRefs := make([]string, 0, 2)
+	ledgerFake := &ledgerclient.Fake{
+		ListConnectorAccountsFn: func(ctx context.Context, req *connectorv1.ListAccountsRequest) (*connectorv1.ListAccountsResponse, error) {
+			listCalls++
+			return &connectorv1.ListAccountsResponse{
+				Accounts: []*connectorv1.Account{
+					{
+						Ref:            &connectorv1.AccountRef{ConnectorId: "ledger", AccountId: accountID},
+						Kind:           connectorv1.AccountKind_LEDGER_ACCOUNT,
+						Asset:          "USD",
+						OwnerRef:       "",
+						ProviderDetails: providerDetails,
+					},
+				},
+			}, nil
+		},
+		CreateTransactionFn: func(ctx context.Context, tx rail.LedgerTx) (string, error) {
+			ledgerAccountRefs = append(ledgerAccountRefs, tx.LedgerAccountRef)
+			return "entry-1", nil
+		},
+	}
+
+	svc := &Service{
+		logger: zap.NewNop(),
+		deps: serviceDependencies{
+			ledger: ledgerDependency{
+				client:   ledgerFake,
+				internal: ledgerFake,
+			},
+		},
+	}
+	executor := newPaymentExecutor(&svc.deps, svc.logger, svc)
+
+	amount := &paymenttypes.Money{Currency: "USD", Amount: "10"}
+	payment := &model.Payment{
+		PaymentRef:     "pay-1",
+		IdempotencyKey: "pay-1",
+		Intent: model.PaymentIntent{
+			Kind: model.PaymentKindPayout,
+		},
+		PaymentPlan: &model.PaymentPlan{
+			ID:             "pay-1",
+			IdempotencyKey: "pay-1",
+			Steps: []*model.PaymentStep{
+				{StepID: "ledger_debit", Rail: model.RailLedger, Action: model.RailOperationDebit, Amount: cloneMoney(amount)},
+				{StepID: "ledger_credit", Rail: model.RailLedger, Action: model.RailOperationCredit, DependsOn: []string{"ledger_debit"}, Amount: cloneMoney(amount)},
+			},
+		},
+	}
+	payment.OrganizationRef = primitive.NewObjectID()
+
+	store := newStubPaymentsStore()
+	store.payments[payment.PaymentRef] = payment
+
+	if err := executor.executePaymentPlan(ctx, store, payment, &orchestratorv1.PaymentQuote{}); err != nil {
+		t.Fatalf("executePaymentPlan error: %v", err)
+	}
+	if listCalls == 0 {
+		t.Fatalf("expected ledger accounts lookup")
+	}
+	if len(ledgerAccountRefs) != 2 {
+		t.Fatalf("expected two ledger transactions, got %d", len(ledgerAccountRefs))
+	}
+	if ledgerAccountRefs[0] != accountID || ledgerAccountRefs[1] != accountID {
+		t.Fatalf("unexpected ledger account refs: %+v", ledgerAccountRefs)
+	}
+}

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

@@ -430,11 +430,14 @@ func (s *helperQuotesStore) GetByRef(_ context.Context, _ primitive.ObjectID, re
 	return nil, storage.ErrQuoteNotFound
 }
 
-func (s *helperQuotesStore) GetByIdempotencyKey(_ context.Context, ref string) (*model.PaymentQuoteRecord, error) {
+func (s *helperQuotesStore) GetByIdempotencyKey(_ context.Context, orgRef primitive.ObjectID, ref string) (*model.PaymentQuoteRecord, error) {
 	if s.records == nil {
 		return nil, storage.ErrQuoteNotFound
 	}
 	for _, rec := range s.records {
+		if rec.OrganizationRef != orgRef {
+			continue
+		}
 		if rec.IdempotencyKey == ref {
 			return rec, nil
 		}

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

@@ -423,11 +423,14 @@ func (s *stubQuotesStore) GetByRef(ctx context.Context, orgRef primitive.ObjectI
 	return nil, storage.ErrQuoteNotFound
 }
 
-func (s *stubQuotesStore) GetByIdempotencyKey(ctx context.Context, idempotencyKey string) (*model.PaymentQuoteRecord, error) {
+func (s *stubQuotesStore) GetByIdempotencyKey(ctx context.Context, orgRef primitive.ObjectID, idempotencyKey string) (*model.PaymentQuoteRecord, error) {
 	if s.quotes == nil {
 		return nil, storage.ErrQuoteNotFound
 	}
 	for _, q := range s.quotes {
+		if q.OrganizationRef != orgRef {
+			continue
+		}
 		if q.IdempotencyKey == idempotencyKey {
 			return q, nil
 		}