Method CommitInflightTransaction

inflight_transaction.go:178–216

CommitInflightTransaction commits an inflight transaction by validating and updating its amount, and finalizing the commitment. It starts a tracing span, fetches and validates the inflight transaction, updates the amount, and finalizes the commitment. Parameters: - ctx context.Context: The context

(ctx context.Context, transactionID string, amount *big.Int)

// - *model.Transaction: A pointer to the committed Transaction model.
// - error: An error if the transaction could not be committed.
func (l *LedgerForge) CommitInflightTransaction(ctx context.Context, transactionID string, amount *big.Int) (*model.Transaction, error) {
	ctx, span := tracer.Start(ctx, "CommitInflightTransaction")
	defer span.End()

	lockKey := fmt.Sprintf("inflight-commit:%s", transactionID)
	locker := redlock.NewLocker(l.redis, lockKey, model.GenerateUUIDWithSuffix("loc"))

	err := locker.Lock(ctx, l.Config().Transaction.LockDuration)
	if err != nil {
		span.RecordError(err)
		return nil, fmt.Errorf("failed to acquire lock for inflight commit: %w", err)
	}
	defer l.releaseSingleLock(ctx, locker)

	transaction, err := l.fetchAndValidateInflightTransaction(ctx, transactionID)
	if err != nil {
		span.RecordError(err)
		return nil, err
	}

	if err := l.validateAndUpdateAmount(ctx, transaction, amount); err != nil {
		span.RecordError(err)
		return nil, err
	}

	span.AddEvent("Inflight transaction committed", trace.WithAttributes(attribute.String("transaction.id", transaction.TransactionID)))
	metrics.InflightCommitTotal.Add(ctx, 1)

	committedTxn, err := l.finalizeCommitment(ctx, transaction, false)
	if err != nil {
		return nil, err
	}

	if err := l.queueShadowWork(ctx, transactionID, model.LineageTypeShadowCommit); err != nil {
		logrus.WithError(err).WithField("transaction_id", transactionID).Error("failed to queue shadow commit")
	}

	return committedTxn, nil
}

func (l *LedgerForge) CommitInflightTransactionWithQueue(ctx context.Context, transactionID string, amount *big.Int) (*model.Transaction, error) {
	ctx, span := tracer.Start(ctx, "CommitInflightTransactionWithQueue")