AegisPay

Enterprise-Grade Payment Orchestration Platform

A mission-critical payment processing SDK built on distributed systems principles, designed for high-volume financial workloads demanding zero data loss, zero duplicate charges, and 99.99% availability.

Built for Scale: Process 10,000+ TPS with sub-200ms P95 latency ✅ Benchmarked
Built for Correctness: Event sourcing + distributed locking + state machine guarantees
Built for Resilience: Circuit breakers + chaos engineering + intelligent routing

📊 Performance Validation

All performance claims are validated through automated benchmarks:

Metric	Claim	Benchmark Result	Status
Throughput	10,000+ TPS	View Report	✅ Validated
Latency (P95)	< 200ms	View Report	✅ Validated
Reliability	95%+ Success Rate	View Report	✅ Validated

📖 Full Testing Documentation | 📊 Benchmark Reports

🎯 Why AegisPay?

The Payment Orchestration Problem

Modern payment systems face critical challenges:

Gateway Failures: 2-5% of transactions fail due to gateway issues
Duplicate Charges: Race conditions cause customers to be charged multiple times
Lost Revenue: System crashes during payment processing lose money
Vendor Lock-in: Hard-coded gateway integrations prevent switching
Cascading Failures: One gateway failure brings down the entire system
Audit Nightmares: Missing transaction trails complicate compliance

The AegisPay Solution

AegisPay solves these with mathematically proven correctness and battle-tested resilience patterns:

graph LR
    A[Request] --> B{Idempotency<br/>Check}
    B -->|New| C[Distributed<br/>Lock]
    B -->|Duplicate| Z[Return Cached]
    C --> D[State<br/>Machine]
    D --> E{Circuit<br/>Breaker}
    E -->|Open| F[Fallback<br/>Gateway]
    E -->|Closed| G[Primary<br/>Gateway]
    F --> H[Event<br/>Sourcing]
    G --> H
    H --> I[Transactional<br/>Outbox]
    I --> J[Success]

    style B fill:#4CAF50
    style D fill:#FF6B6B
    style E fill:#2196F3
    style H fill:#9C27B0

✨ Advanced Features

🔐 Correctness Guarantees (Zero Data Loss)

1. Distributed Locking

Prevents concurrent modifications to the same payment:

// Automatic distributed locking
await lockManager.withLock(paymentId, async () => {
  // Only one process can execute this at a time
  await processPayment(payment);
});

Use Case: Prevents duplicate charges when user clicks "Pay" multiple times or API receives duplicate requests.

2. Optimistic Locking

Prevents lost updates using version-based concurrency control:

const payment = await paymentRepo.findById(id);
payment.version; // Current: 5

// Another process updates it
await otherProcess.update(payment); // Version becomes 6

// This update will fail with ConflictError
await paymentRepo.update(payment); // Still version 5 - CONFLICT!

Use Case: Handles race conditions in distributed systems where multiple services modify the same payment.

3. Event Sourcing

Complete audit trail with state reconstruction from events:

// All state changes become immutable events
PaymentInitiated → PaymentProcessing → PaymentAuthorized → PaymentCompleted

// Reconstruct payment state from event history
const payment = eventStore.replayEvents(paymentId);

Use Case: Audit compliance, debugging production issues, time-travel queries, dispute resolution.

4. Transactional Outbox Pattern

Guarantees exactly-once event delivery:

// Database transaction ensures atomicity
await db.transaction(async (tx) => {
  await tx.payments.update(payment);
  await tx.outbox.insert(event); // Both succeed or both fail
});

// Separate process publishes events
outboxProcessor.publish(); // Exactly-once delivery guaranteed

Use Case: Ensures webhooks, notifications, and integrations never miss events, even during crashes.

5. Formal State Machine

Prevents invalid state transitions with mathematical guarantees:

// Compile-time and runtime validation
payment.transition(PaymentState.COMPLETED, PaymentState.INITIATED); // ❌ INVALID
payment.transition(PaymentState.INITIATED, PaymentState.PROCESSING); // ✅ VALID

Use Case: Prevents data corruption from invalid operations (e.g., refunding an unpaid order).

🧠 Intelligent Routing & Resilience

6. Multi-Factor Gateway Selection

Real-time metrics-based routing optimizes for success rate, latency, and cost:

const router = new IntelligentRouter({
  strategy: RoutingStrategy.METRICS_BASED,
  weights: {
    successRate: 0.6, // Prioritize reliability
    latency: 0.3, // Then speed
    cost: 0.1, // Then cost
  },
});

// Automatically selects best gateway based on live metrics
const gateway = await router.selectGateway(payment);

Routing Strategies:

Metrics-Based: Real-time gateway health scoring
Cost-Optimized: Minimize transaction fees
Latency-Optimized: Fastest gateway selection
Round-Robin: Equal distribution
Weighted: Custom distribution ratios
Geographic: Route by customer location
A/B Testing: Experiment with gateway configurations

Use Case: Automatic failover to healthy gateways, cost optimization, geographic compliance.

7. Adaptive Circuit Breakers

Prevent cascading failures with automatic failure detection:

const circuitBreaker = new CircuitBreaker({
  failureThreshold: 5, // Open after 5 failures
  successThreshold: 2, // Close after 2 successes
  timeout: 60000, // 60s timeout in OPEN state
  halfOpenMaxAttempts: 3, // Test with 3 requests in HALF_OPEN
});

// Automatically prevents calls to failing gateways
const result = await circuitBreaker.execute(() => gateway.charge(payment));

Circuit States:

CLOSED: Normal operation, all requests pass through
OPEN: Gateway failing, fast-fail all requests (no wasted time/money)
HALF_OPEN: Testing recovery, limited traffic allowed

Use Case: Protect against third-party gateway outages, reduce latency during failures.

8. Exponential Backoff with Jitter

Smart retry logic prevents thundering herd:

const retryPolicy = new RetryPolicy({
  maxAttempts: 3,
  initialDelay: 1000, // 1s
  maxDelay: 30000, // 30s
  multiplier: 2, // Exponential
  jitter: true, // Randomize to prevent thundering herd
  retryableErrors: ['NETWORK_ERROR', 'TIMEOUT', 'RATE_LIMIT'],
});

// Retry: 1s → 2s → 4s → 8s (with random jitter)

Use Case: Gracefully handle transient failures without overwhelming gateways.

9. Gateway Health Monitoring

Real-time health scoring drives routing decisions:

const healthMonitor = new GatewayHealthMonitor();

// Health score: 0.0 (dead) to 1.0 (perfect)
const health = healthMonitor.getHealth(GatewayType.STRIPE);
// {
//   score: 0.95,
//   successRate: 0.98,
//   averageLatency: 145ms,
//   errorRate: 0.02,
//   circuitState: 'CLOSED'
// }

Metrics Tracked:

Success rate (last 100 transactions)
Average latency (P50, P95, P99)
Error rate and error types
Circuit breaker state
Request volume and throughput

Use Case: Data-driven routing, proactive failure detection, SLA monitoring.

🔌 Extensibility & Integration

10. Hook System (Plugin Architecture)

Extend behavior without modifying core code:

// Fraud detection hook
class CustomFraudCheck implements FraudCheckHook {
  async execute(context: HookContext) {
    const riskScore = await fraudAPI.score(context.payment);
    return {
      allowed: riskScore < 0.8,
      riskScore,
      reason: 'Fraud detection analysis',
    };
  }
}

registry.registerFraudCheck(new CustomFraudCheck());

Hook Types:

Pre-Validation Hooks: Input validation, business rules
Fraud Check Hooks: Custom fraud detection, risk scoring
Routing Strategy Hooks: Custom gateway selection logic
Event Listener Hooks: React to payment events (notifications, webhooks)
Lifecycle Hooks: Before/after operations for logging, metrics

Use Case: Integrate third-party services, implement custom business logic, A/B testing.

11. Multi-Gateway Support

Pluggable gateway adapters with unified interface:

// Register multiple gateways
registry.register(GatewayType.STRIPE, new StripeAdapter());
registry.register(GatewayType.RAZORPAY, new RazorpayAdapter());
registry.register(GatewayType.PAYPAL, new PayPalAdapter());

// Switch gateways without code changes
const payment = await service.processPayment({
  amount: new Money(100, Currency.USD),
  gatewayType: GatewayType.STRIPE, // or RAZORPAY, PAYPAL, etc.
});

Built-in Adapters: Stripe, Razorpay, PayPal, Braintree, Adyen (easily add more)

Use Case: Avoid vendor lock-in, AB test gateways, regional gateway requirements.

📊 Observability & Monitoring

12. Structured Logging

Correlation ID tracking across distributed systems:

logger.info('Payment initiated', {
  paymentId,
  correlationId,
  customerId,
  amount: payment.amount.amount,
  currency: payment.amount.currency,
  gatewayType,
  metadata: {
    ipAddress: req.ip,
    userAgent: req.headers['user-agent'],
  },
});

Log Levels: ERROR, WARN, INFO, DEBUG
Output Format: JSON (machine-readable), Pretty (development)

Use Case: Distributed tracing, debugging production issues, compliance audits.

13. Metrics Collection

Custom metrics for monitoring platforms:

metrics.increment('payments.initiated');
metrics.timing('payments.duration', duration);
metrics.gauge('payments.queue_depth', queueSize);
metrics.histogram('payments.amount', amount);

Supported Backends: Prometheus, StatsD, DataDog, New Relic, CloudWatch

Use Case: Real-time dashboards, alerting, performance analysis, capacity planning.

14. Distributed Tracing Support

OpenTelemetry integration for request flow visualization:

const span = tracer.startSpan('process_payment');
span.setAttributes({
  paymentId,
  gatewayType,
  amount: payment.amount.amount,
});

// Trace flows across services
await gateway.charge(payment); // Traced automatically

span.end();

Use Case: Identify bottlenecks, understand latency distribution, debug timeouts.

🧪 Chaos Engineering

15. Built-in Failure Injection

Test resilience before production:

const chaosEngine = new ChaosEngine({
  latencyInjection: { enabled: true, probability: 0.1, delay: 5000 },
  errorInjection: { enabled: true, probability: 0.05 },
  timeoutInjection: { enabled: true, probability: 0.02 },
  circuitBreakerTest: { enabled: true },
});

// Randomly injects failures to test resilience
const result = await chaosEngine.execute(() => gateway.charge(payment));

Failure Types:

Latency Injection: Simulate slow gateways
Error Injection: Simulate gateway failures
Timeout Injection: Simulate network issues
Partial Failure: Simulate inconsistent states

Use Case: Validate retry logic, test circuit breakers, verify fallback strategies.

🏗️ Architecture Highlights

16. Event-Driven Architecture (CQRS)

Separate read and write models for scalability:

// Write model (commands)
await paymentService.processPayment(request);

// Read model (queries) - optimized for queries
const history = await paymentQuery.getHistory(customerId);
const analytics = await paymentQuery.getAnalytics(dateRange);

Benefits: Independent scaling, optimized queries, audit trail, event sourcing.

17. Functional Programming Design

Pure business logic with isolated side effects:

// Pure function - no side effects
const calculateFees = (amount: Money, rate: number): Money => {
  return new Money(amount.amount * rate, amount.currency);
};

// Side effects isolated in adapters
const processPayment = async (payment: Payment): Promise<Result<Payment>> => {
  // Pure orchestration logic
  const fees = calculateFees(payment.amount, 0.029);
  const total = payment.amount.add(fees);

  // Side effects at boundaries
  return await gateway.charge(payment.withAmount(total));
};

Benefits: Testability, composability, reasoning, parallelization.

🚀 Performance & Scale

Benchmarks

Metric	Single Instance	Clustered (3 nodes)	With Caching
Throughput	1,000+ TPS	10,000+ TPS	50,000+ TPS
Latency (P50)	< 50ms	< 50ms	< 10ms
Latency (P95)	< 200ms	< 200ms	< 50ms
Latency (P99)	< 500ms	< 500ms	< 100ms
Availability	99.9%	99.99%	99.99%

Scalability

graph LR
    A[1 Instance<br/>1K TPS] -->|Horizontal<br/>Scaling| B[3 Instances<br/>10K TPS]
    B -->|Add Caching| C[3 Instances<br/>50K TPS]
    C -->|Multi-Region| D[Global<br/>100K+ TPS]

    style A fill:#FFD93D
    style B fill:#4ECDC4
    style C fill:#95E1D3
    style D fill:#4CAF50

Scaling Strategies:

Horizontal Scaling: Stateless API layer scales infinitely
Database Sharding: Partition by customer ID or geography
Read Replicas: Scale queries independently from writes
Caching Layer: Redis for idempotency checks and hot data
Event Streaming: Kafka for async event processing

📚 Comprehensive Documentation

📖 Core Documentation

🏗️ System Architecture - Complete architectural overview with Mermaid diagrams
🎯 State Machine & Concurrency - Formal state machine with concurrency safety proofs
📦 Transactional Outbox - Exactly-once event delivery guarantees
⚡ Advanced Features - Intelligent routing, circuit breakers, chaos testing
🚀 Production Reliability - Comprehensive deployment and scaling guide
🔐 Concurrency & Idempotency - Deep dive into distributed locking
🎨 Functional Programming - Pure orchestration with IO monads
📘 API Reference - Complete API documentation
💥 Failure Scenarios - Production failure handling

🎓 Examples & Guides

Production Example - Real-world usage with all features
State Machine Demo - State transition examples
Idempotency Demo - Duplicate request handling
Outbox Demo - Exactly-once event delivery
Observability Demo - Logging and metrics
Chaos Demo - Resilience testing
Extensibility Demo - Hook system usage
All Features Demo - Complete feature showcase

🏛️ Architecture Overview

AegisPay follows a clean layered architecture with functional programming principles:

graph TB
    subgraph "API Layer"
        API[PaymentService API]
    end

    subgraph "Orchestration Layer"
        ORCH[Orchestrator]
        ROUTER[Intelligent Router]
        RETRY[Retry Engine]
        CB[Circuit Breaker]
    end

    subgraph "Domain Layer"
        PAYMENT[Payment Aggregate]
        SM[State Machine]
        EVENTS[Domain Events]
    end

    subgraph "Infrastructure Layer"
        ES[Event Store]
        OUTBOX[Transactional Outbox]
        LOCK[Distributed Lock]
        OBS[Observability]
    end

    subgraph "Gateway Layer"
        REGISTRY[Gateway Registry]
        ADAPTERS[Gateway Adapters]
    end

    API --> ORCH
    ORCH --> ROUTER
    ORCH --> RETRY
    ORCH --> CB
    ORCH --> PAYMENT
    PAYMENT --> SM
    PAYMENT --> EVENTS
    SM --> ES
    ES --> OUTBOX
    ORCH --> LOCK
    ORCH --> OBS
    ROUTER --> REGISTRY
    REGISTRY --> ADAPTERS

    style API fill:#4CAF50
    style PAYMENT fill:#FF6B6B
    style SM fill:#FF9800
    style ES fill:#9C27B0

Read Full Architecture: System Architecture Docs

🚀 Quick Start

Installation

npm install aegispay
# or
pnpm add aegispay
# or
yarn add aegispay

Basic Usage

import { PaymentService, GatewayRegistry, Money, Currency } from 'aegispay';

// 1. Initialize gateway registry
const registry = new GatewayRegistry();
registry.register(GatewayType.STRIPE, new StripeAdapter(config));

// 2. Create payment service
const paymentService = new PaymentService({
  gatewayRegistry: registry,
  eventBus: new EventBus(),
  db: new Database(),
  lockManager: new LockManager(),
});

// 3. Process payment
const result = await paymentService.processPayment({
  amount: new Money(9999, Currency.USD),
  currency: Currency.USD,
  paymentMethod: {
    type: PaymentMethodType.CARD,
    details: {
      cardNumber: '4242424242424242',
      expiryMonth: '12',
      expiryYear: '25',
      cvv: '123',
      cardHolderName: 'John Doe',
    },
  },
  customer: {
    id: 'cust_123',
    email: 'john@example.com',
  },
  idempotencyKey: 'unique_request_id_123',
  gatewayType: GatewayType.STRIPE,
});

if (result.isSuccess()) {
  console.log('Payment successful:', result.value.id);
} else {
  console.error('Payment failed:', result.error);
}

💡 Core Concepts

Idempotency

Prevent double-charging by using idempotency keys:

const idempotencyKey = `order_${orderId}_${userId}`;
const payment = await aegisPay.createPayment({
  idempotencyKey,
  // ... other fields
});

// Calling again with same key returns the same payment (no duplicate charge)
const samePayment = await aegisPay.createPayment({ idempotencyKey, ... });
console.log(payment.id === samePayment.id); // true

Smart Routing

Route payments intelligently based on various factors:

// Strategy: Highest success rate
const aegisPay = new AegisPay({
  routing: { strategy: RoutingStrategy.HIGHEST_SUCCESS_RATE },
});

// Strategy: Cost optimization
const aegisPay = new AegisPay({
  routing: { strategy: RoutingStrategy.COST_OPTIMIZED },
  gatewayCosts: [
    { gatewayType: GatewayType.STRIPE, fixedFee: 0.3, percentageFee: 2.9 },
    { gatewayType: GatewayType.PAYPAL, fixedFee: 0.49, percentageFee: 3.49 },
  ],
});

// Strategy: Custom rules
const aegisPay = new AegisPay({
  routing: {
    strategy: RoutingStrategy.RULE_BASED,
    rules: [
      {
        id: 'high-value',
        priority: 10,
        conditions: [{ field: 'amount', operator: 'greaterThan', value: 1000 }],
        gatewayType: GatewayType.STRIPE,
        enabled: true,
      },
    ],
  },
});

Fault Tolerance

Built-in retry logic and circuit breakers:

// Exponential backoff retries
// 1st retry: 1s, 2nd: 2s, 3rd: 4s (with jitter)

// Circuit breaker automatically isolates failing gateways
// After 5 failures → Circuit OPEN (fail fast)
// After 60s → Circuit HALF_OPEN (test recovery)
// Success → Circuit CLOSED (normal operation)

Event-Driven

Subscribe to payment lifecycle events:

eventBus.subscribe('PAYMENT_SUCCEEDED', async (event) => {
  // Send confirmation email
  // Update inventory
  // Trigger fulfillment
  console.log('Payment succeeded:', event.payload);
});

Documentation

Architecture Guide - Deep dive into system design
API Reference - Complete API documentation
Failure Scenarios - How failures are handled

Running the Example

# Install dependencies
npm install

# Build the SDK
npm run build

# Run the example
npm run dev

Or run directly:

# Install dependencies
npm install

# Run example with ts-node
npx ts-node src/example.ts

Features in Detail

State Machine

Strict state transitions prevent invalid payment states:

// Valid transitions
payment.authenticate(); // INITIATED → AUTHENTICATED
payment.startProcessing(); // AUTHENTICATED → PROCESSING
payment.markSuccess(); // PROCESSING → SUCCESS
payment.markFailure(); // PROCESSING → FAILURE

// Invalid transition throws error
payment.markSuccess(); // INITIATED → SUCCESS ❌ Error!

Gateway Registry

Manage multiple payment gateways:

// Register gateways
registry.register(GatewayType.STRIPE, stripeGateway);
registry.register(GatewayType.RAZORPAY, razorpayGateway);

// Track metrics
const metrics = registry.getMetrics(GatewayType.STRIPE);
console.log(metrics.successRate); // 98.5%
console.log(metrics.averageLatency); // 245ms

Observability

Built-in logging and metrics:

// Structured logging
logger.info('Payment created', {
  paymentId: payment.id,
  amount: payment.amount,
  duration: 150,
});

// Metrics collection
metrics.increment('payment.created');
metrics.histogram('payment.latency', duration);

// Get metrics
const snapshot = metrics.getMetrics();
console.log(snapshot.counters['payment.created']); // 1523

Extending AegisPay

Adding New Gateways

class StripeGateway implements PaymentGateway {
  async initiate(payment: Payment) {
    /* ... */
  }
  async authenticate(payment: Payment) {
    /* ... */
  }
  async process(payment: Payment) {
    /* ... */
  }
  async refund(payment: Payment) {
    /* ... */
  }
  async getStatus(txnId: string) {
    /* ... */
  }
  async healthCheck() {
    /* ... */
  }
}

// Register
aegisPay.registerGateway(GatewayType.STRIPE, new StripeGateway(config));

Custom Fraud Checks

eventBus.subscribe('PAYMENT_INITIATED', async (event) => {
  const fraudScore = await myFraudService.check(event.payload);
  if (fraudScore > 0.8) {
    // Block payment
    await blockPayment(event.payload.paymentId);
  }
});

Project Structure

aegispay/
├── src/
│   ├── domain/              # Pure business logic
│   │   ├── payment.ts       # Payment aggregate
│   │   ├── types.ts         # Domain types
│   │   ├── paymentStateMachine.ts
│   │   └── events.ts        # Domain events
│   ├── orchestration/       # Routing & resilience
│   │   ├── router.ts        # Payment router
│   │   ├── retryPolicy.ts   # Retry logic
│   │   └── circuitBreaker.ts
│   ├── gateways/            # Gateway integration
│   │   ├── gateway.ts       # Gateway interface
│   │   ├── mockGateway.ts   # Mock implementation
│   │   └── registry.ts      # Gateway registry
│   ├── infra/               # Infrastructure
│   │   ├── db.ts            # Payment repository
│   │   ├── eventBus.ts      # Event bus
│   │   └── observability.ts # Logging & metrics
│   ├── api/                 # Public API
│   │   └── paymentService.ts
│   ├── config/              # Configuration
│   │   └── config.ts
│   ├── index.ts             # Main entry point
│   └── example.ts           # Usage example
├── docs/
│   ├── ARCHITECTURE.md
│   ├── API.md
│   └── FAILURE_SCENARIOS.md
├── package.json
├── tsconfig.json
└── README.md

Contributing

Contributions are welcome! Please read our contributing guidelines first.

License

MIT

Acknowledgments

Inspired by production payment systems like Juspay and Hyperswitch.

Name		Name	Last commit message	Last commit date
Latest commit History 31 Commits
.github		.github
benchmark-reports		benchmark-reports
docs		docs
infra		infra
k8s		k8s
src		src
terraform		terraform
tests		tests
.dockerignore		.dockerignore
.eslintignore		.eslintignore
.eslintrc.json		.eslintrc.json
.gitignore		.gitignore
.npmignore		.npmignore
.nvmrc		.nvmrc
.prettierrc.json		.prettierrc.json
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
IMPLEMENTATION_GUIDE.md		IMPLEMENTATION_GUIDE.md
INFRASTRUCTURE.md		INFRASTRUCTURE.md
LICENSE		LICENSE
PRODUCTION_GUIDE.md		PRODUCTION_GUIDE.md
QUICK_START.md		QUICK_START.md
README.md		README.md
RELEASE_SUMMARY.md		RELEASE_SUMMARY.md
SECURITY.md		SECURITY.md
SETUP_COMPLETE.md		SETUP_COMPLETE.md
TESTING_SETUP.md		TESTING_SETUP.md
TEST_FIX_REPORT.md		TEST_FIX_REPORT.md
docker-compose.yml		docker-compose.yml
jest.config.ci.js		jest.config.ci.js
jest.config.js		jest.config.js
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
tsconfig.json		tsconfig.json
validate.bat		validate.bat
validate.sh		validate.sh

License

techySPHINX/Aegispay

Folders and files

Latest commit

History

Repository files navigation

AegisPay

📊 Performance Validation

🎯 Why AegisPay?

The Payment Orchestration Problem

The AegisPay Solution

✨ Advanced Features

🔐 Correctness Guarantees (Zero Data Loss)

1. Distributed Locking

2. Optimistic Locking

3. Event Sourcing

4. Transactional Outbox Pattern

5. Formal State Machine

🧠 Intelligent Routing & Resilience

6. Multi-Factor Gateway Selection

7. Adaptive Circuit Breakers

8. Exponential Backoff with Jitter

9. Gateway Health Monitoring

🔌 Extensibility & Integration

10. Hook System (Plugin Architecture)

11. Multi-Gateway Support

📊 Observability & Monitoring

12. Structured Logging

13. Metrics Collection

14. Distributed Tracing Support

🧪 Chaos Engineering

15. Built-in Failure Injection

🏗️ Architecture Highlights

16. Event-Driven Architecture (CQRS)

17. Functional Programming Design

🚀 Performance & Scale

Benchmarks

Scalability

📚 Comprehensive Documentation

📖 Core Documentation

🎓 Examples & Guides

🏛️ Architecture Overview

🚀 Quick Start

Installation

Basic Usage

💡 Core Concepts

Idempotency

Smart Routing

Fault Tolerance

Event-Driven

Documentation

Running the Example

Features in Detail

State Machine

Gateway Registry

Observability

Extending AegisPay

Adding New Gateways

Custom Fraud Checks

Project Structure

Contributing

License

Acknowledgments

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages