Skip to content
BranchesTags

Repository files navigation

Product::PayTech

  • Description: PayTech, Payment & Wallet Technologies, Wallet for Centralized and Decentralized (Blockchain, Crypto) Wallets
  • Project Progress Strategy: In terms of project progress, the initial phase will involve building a monolithic structure with the core features, which will later be transitioned to a microservices architecture
  • Repositories: https://github.com/mustafaakgul/paytech
  • Areas
    • Area 2 (PayTech Project): Digital Wallet (Online, Mobile, Digital, E, Prepaid, Contacless, Bank-Listed, Closed, Open, Cryptocurrency, P2P), Apple Wallets Pay, Google Wallets Pay, Paypal, Venmo, Zelle, Cash App, Amazon Pay, Dwolla
    • Area 5 (PayTech Project): PayTech/Exchange Systems - Ödeme Sistemleri, Money Transfer, Mobile Payment, QR, Cart, NFC, SMS, via Link, BNPL, Online Ödeme, Prepaid, Temassıs, Embedded Finance, Central Bank Digital Currencies, Uluslararası Para Transferleri, SanalPos, Seal, Open Banking, Embedded Payment, Banking as a Service, API Aracılığıyla Fintech ve Bankaları Baglamak

To Run Application

  • Build: mvn clean package
  • Local: ./mvnw spring-boot:run
  • Dev: https://dashboard.heroku.com/apps/{APP_NAME}, heroku pg:info -a {APP_NAME}
  • Production: Maven: java -jar target/org-fintech-paytech-0.1.0.jar, Gradle: java -jar build/libs/org-fintech-paytech-0.1.0.jar
    • java -Dspring.profiles.active=prod -Dserver.port=$PORT -jar build/libs/{APP_NAME}.heroku.app-0.0.1-SNAPSHOT.jar,
    • java -Dserver.port=$PORT -jar target/.jar, build/libs/.jar

Architecture

  • // TODO:

Technology Stack

  • Language: Java
  • Build Tool: Maven
  • Packaging: JAR
  • Framework: Spring & Spring Boot
  • IDE: IntelliJ IDEA
  • API Type: RESTful
  • API Testing: Postman, IntelliJ HTTP Client, CURL
  • Database: PostgreSQL
  • Database Client: IntelliJ Database Tool
  • API Documentation: Swagger Integration
  • Spring Boot Dev Tools: Build Automatically, etc.
  • Spring Data JPA
  • Spring Security
  • Decoding: jwt.io
  • ORM: Hibernate
  • Version Control: Git
  • Source Code Management: GitHub
  • Deployment: Docker & Docker Compose, Dev-Heroku, Prod-Heroku
  • Logging: Structural Logging, SLF4J and Logback by Default, Advanced Logging with ELK Stack (Elasticsearch, Logstash, Kibana)
  • Error Monitoring: Sentry
  • Core App Management: Slack

Features

  • Accounts
  • Transactions

Best Practices

  • Star Project on GitHub
  • Share on GitHub & Remove git Cache - git rm -r --cached {FILE_NAME}
  • Add GitHub Topics for Repository
  • Add GitHub Description for Repository
  • Add GitHub License for Repository in GitHub
  • Add GitHub Languages
  • Pin Primary Repositories
  • Watch Activities of Repository
  • Project Naming Standards: x-y, Lowercase with Dashes
  • Add .gitignore File in IDE or Generating Web
  • Add README.md: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
  • Add Yourself as a Watcher
  • Commit Message Standards: Fix Part, Add Update Fix Refactor Remove Release Merge Hotfix Revert Initial
  • Use Feature Branches, Pull Requests and Code Reviews
  • Use GitHub Discussions
  • Use GitHub Issues and Projects
  • Use GitHub Wiki and Gist
  • Create Documentation: https://www.jetbrains.com/help/pycharm/documenting-source-code.html
  • Use // TODO: for Empty Sections
  • Response Entity / Builder
  • Name Methods in a Descriptive Way: "createAccount" instead of "create" for many creative methods can be existing
  • Generic Response Model
  • DTO Objects with DomainRequestDTO, DomainResponseDTO, DomainDTO (Same if Equals Resp Req), DomainRequest, DomainResponse, {Action}DomainRequest, {Action}DomainResponse, {Action}DomainDTO
  • Objects Mapping instead of Manual Conversion: Conversion in Controller Layer Cuz of Service Layer Only Works with Real Objects and Better Implementation of Http Response (Controller) Not Exception (Service) <-> Sometimes Conversion is Better in Service Layer
  • Spring Boot Project Architecture & Structure & Template: By Feature, By Layer, Mixed
  • Use .orElseThrow() to Return Exception, .orElseGet() to Return Method and .orElse() to Return Str for Optional
  • Instead of Null Checking, Use methods like Optional, isPresent(), isEmpty() and orElse(null) for Nullable Singular Objects, or NullSafe., etc, if (user.isPresent()) return user.get() else return null -> User Single Line .orElse(null). For lists if (user.isEmpty()) return List.of() instead of //throw new EntityNotFoundException("Authenticated user not found"). Some cases need orElseThrow()
  • Use Global Exception Handler and Controller Advice for Centralized Management instead of Exceptions and Errors try(throw exception)-catch(handle exception)finally blocks except for special cases uses where custom handling (repeat task, try again, etc.) is required
    • Specific Case Example: catch {UserNotFoundException ex} throw new UserNotFoundException(); catch {Exception ex} throw new RuntimeException("Unexpected error occurred", ex);
    • Catching with Specific Exception (Better approach is global exception cuz we know type not general try-catch), Use Finally Resource Management
    • Use Global Generic "Exception" Handler for Centralized Exception Management instead of using try-catch for General Exception (Exception.class handleException)
    • Do Not Use Centralized Exception for in case of retry logic, fallback mechanism like backup services, or custom handling
  • API Temp

Architecture To Be

  • Presentation Layer
    • Authentication
    • JSON Transformation
  • Business Layer
    • Business Logic
    • Validation
    • Authorization
  • Persistence Layer
    • Storage Logic
  • Database Layer
    • Actual Database
  • API Gateway Feature
    • Centralized API Management
    • Rate Limiting
    • Authentication and Authorization
    • Caching
    • Logging and Monitoring

Technology Stack To Be

Features To Be

  • Exchange Systems: Bitcoin, Etherium, Tron, Solana
  • Kalman and Other Predictive Models
  • Providing options such as interest or monetary returns
  • Investment recommendations to help the customer earn profits
  • Providing Money Earning Models
  • Shallow and Not in-Depth Budget: Income, Expenses, Balance, Shallow Assets (Accounts, Total “under-the-pillow” savings), Financial Goal and Freedom and Financial Retirement, Retrieves Account Balances and Income then subtracts to show Expenses.
  • MCP Integration: Samples like one click account create
  • Allow App to Track
  • Allow Push Notification
  • User Management
  • Transaction Bookmark (Favorite)
  • Report (Stats)
  • On-Boarding
  • Budgeting AI Suggestions
  • Swagger Documentation
  • Ortak Chat
  • Montly Goals
  • (Long Terms)Currency Support
  • (Long Terms)Format Support
  • (Long Terms)Team Budget as Feature or as App
  • (Long Terms)No-Add
  • (Long Terms)Language Support
  • (Long Terms)UI: Space Grey Version, Dark Version, White Version, And Many Color Themes
  • Central Digital Wallet (Merkeziyetli Wallet)
  • Blockchain Solana Based Digital Wallet (Merkeziyetsiz Wallet)
  • Target No
  • Shortener App Feature

Best Practices To Be

  • Add GitHub Website
  • Add GitHub Releases
  • Add GitHub Tags
  • Add GitHub Packages
  • Add GitHub Deployments
  • Add GitHub Workflows
  • Concept Folder is Singular: config, security, etc
  • Files are Singular and CamelCase
  • Naming Conventions
  • https://medium.com/javarevisited/10-spring-boot-best-practices-to-learn-in-10-minutes-b4ea307b2a84
  • https://dev.to/jazzybruno/spring-boot-project-folder-structure-12oe
  • https://www.javatpoint.com/spring-boot-architecture
  • https://medium.com/the-resonant-web/spring-boot-2-0-project-structure-and-best-practices-part-2-7137bdcba7d3
  • https://malshani-wijekoon.medium.com/spring-boot-folder-structure-best-practices-18ef78a81819
  • https://docs.spring.io/spring-boot/reference/using/structuring-your-code.html
  • Use Modular Programming for reusable modules
  • Reformat Code, Optimize Imports, Rearrange Code in IntelliJ IDEA,
  • Empty Last Line .class Files
  • Code Linters
  • Code Formatters
  • Use .keep in Empty Folder
  • Use Singular Folder Naming for Irregular Nouns Dirty and Java Community Standards
  • Use IDE Debugger for debugging.
  • AI CoPilot as: Agent, MCP Server, Pull Request, Code Review, Code Generation, Pair Programming, Team Member, Code Refactoring, Code Documentation, Code Testing, Code Debugging, Code Optimization, Understanding Code, Research.
  • Use POJOs (Plain Old Java Objects) for data transfer objects (DTOs) and entities. DTOs normally are created as POJOs.
  • Use Validations
  • Performance Monitoring
  • Commit Message Standards: Fix Part, Add Update Fix Refactor Remove Release Merge Hotfix Revert Initial
  • Use wrapper classes for fundamental data types (e.g., Integer instead of int).
  • BigDecimal for monetary values instead of double or float in FinTech.
  • Use TODO: comments for unfinished tasks or features.
  • Use Health Check for application health monitoring. Spring Boot Actuator provides endpoints for health checks.
  • Metrics Collection: Use Micrometer for collecting application metrics.
  • Structured Logging: Use a structured logging framework. Application and physical logs like cpu.
  • Monitoring Setup: Use Prometheus and Grafana for monitoring and visualization.
  • Use properties files for all static string in the project. For instance CrossOrigin(origins = "${cross.origin.url}") instead of CrossOrigin(origins = "http://localhost:4200")
  • Do not use @Autowired annotation for constructor injection. Use constructor directly.
  • Do not use wildcard (*) imports.
  • Use command + shift + N to create scratch files in IntelliJ IDEA like properties, json, HTTP request, etc.
  • Prevent Race Condition, Transaction Locking
  • API Dev: Contract-First Approach (Talk to Business Unit), OpenAPI Spec, API Documentation, Code Generation, Maintainability
  • Spring Security: Use UserDetails and UserDetailsService implement for Grants, loadUserByUsername, etc.
  • MCP Server
  • Database Naming Conventions:
  • HTTP Status Codes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
  • HTTP Methods:
    • GET: Retrieve data
    • POST: Create new resource
    • PUT: Update existing resource
    • PATCH: Partially update existing resource, small changes in big resource (data)
    • DELETE: Remove resource
  • HOW MUCH REST API: Richardson Maturity Model (0 to 3 - worst to best)
    • Level 0: Swamp of POX: Single Endpoint, Uses HTTP as tunnel, Soap over HTTP ("There's a single service that determines what to do based on the contents of the payload)
    • Level 1: Resources: Multiple Endpoints, Single HTTP Method like Everything works over POST, Ex: /users/1234
    • Level 2: HTTP Methods (Verbs): Proper use of HTTP methods, Status Codes, Ex: GET /users/123
    • Level 3: Hypermedia Controls: HATEOAS: Hypermedia controls, Self-discovering API, Ex: Links in responses
  • Production Best Practices:
  • Scability Patterns:
    • Load Balancing: Distribute incoming requests across multiple instances.
    • Horizontal Scaling: Add more instances to handle increased load.
    • Vertical Scaling: Increase resources (CPU, RAM) of existing instances.
    • Caching Strategies: Use in-memory caches like Redis or Memcached to reduce database load.
    • Asynchronous Processing: Use message queues (e.g., RabbitMQ, Kafka) for background processing.
    • Database Sharding: Split large databases into smaller, more manageable pieces.
  • Security Best Practices:
    • Use HTTPS for secure communication.
    • Implement JWT Authentication for stateless sessions.
    • Use OAuth2 for third-party integrations.
    • Validate and sanitize all user inputs to prevent SQL injection and XSS attacks.
    • Implement Role-Based Access Control (RBAC) for authorization.
    • Regularly update dependencies to patch vulnerabilities.
    • Use environment variables for sensitive configurations.
    • Monitor application logs for suspicious activities.
    • Authentication and Authorization.
    • Data Encryption, Do not store sensitive data in plain text in DBs, use Vaults or Encryption Libraries.
    • API Gateway for Centralized Security.
    • Input Validation and Sanitization.
    • Error Handling
  • Monitoring Strategies: Application metrics, infrastructure monitoring, log aggregation, tracing, alerting.
    • Use Prometheus for metrics collection.
    • Use Grafana for visualization of metrics.
    • Set up alerts for critical metrics (e.g., error rates, response times).
    • Use distributed tracing tools like Jaeger or Zipkin for performance monitoring.
    • Log aggregation with tools like ELK Stack (Elasticsearch, Logstash, Kibana) or Fluentd.
  • Documentation Best Practices:
    • Use OpenAPI Specification (OAS) for API documentation.
    • Generate API documentation using Swagger or Spring REST Docs.
    • Keep documentation up-to-date with code changes.
    • Provide examples for API endpoints.
    • Document error responses and status codes.
    • Use Markdown for README files and project documentation.
    • Technical Documentation: AI or Human Generated.
    • User Guides
    • Inline Code Documentation: Javadoc for Java code.
    • Change Logs
  • Custom Response Model
  • Error Handling
  • Unit Testing
  • Port Clean: lsof -i:8091 -> kill -9
  • Static Code Analysis: SonarQube, SonarLint Tools
  • Linting Tools Integration
  • AI Tools Integration in Daily Development
  • Kafka Integration for Event-Driven Architecture: Notification, Moment Notification for Fraud Cases, Logging, Analytics, Fraud, etc.
  • Skills: Internet, OS, Data Structures, Algorithms, Language, Version Control, Framework, Database, API, Testing, CI/CD, Containerization, Web Servers
  • Flow: Client Request -> DispatcherServler -> Handler Mapping -> Controller -> Service -> Repository and Data Access -> Database -> Response Handling -> DispatcherServler Response
  • Response Entity/Builder: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/http/ResponseEntity.html: Use ResponseEntity with Generic Response Instead of Return Model
  • Name Methods in a Descriptive Way: "createAccount" (GetBy{Feature}) instead of "create" for many creative methods can be existing. For Instance: Do not (Controller: getById, create, getAll, update, delete, Repo: deleteById, save, findbyId, findAll)
  • Use Makefile
  • Logging Best Practices:
  • Use Aspect Oriented Programming (AOP) for cross-cutting concerns like logging, security, transaction management, tracing, validation, caching, performance tracking, call lazy entity, etc.
  • Preparing Production:
  • Use meaningful name instead of underscore (_) variable names. (savedTrx instead of _trx)
  • Use service layer for business logic not infrastructure concerns like exception handling, logging, etc.
  • Reduce boilerplate code by using annotations,
  • For DTO Handling great layer is controller (Maybe sometimes service) layer
  • Add AI Reviewer
  • Add Docker Dept
  • Add Sentry
  • Star Project on GitHub
  • Share on GitHub & Remove git Cache - git rm -r --cached .idea
  • Add GitHub Topics for Repository
  • Add GitHub Description for Repository
  • Add GitHub License for Repository in GitHub
  • Project Naming Standards: x-y, Lowercase with Dashes
  • Add .gitignore File in IDE or Generating Web
  • Add README.md: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
  • Add Yourself as a Watcher
  • Commit Message Standards: Fix Part, Add Update Fix Refactor Remove Release Merge Hotfix Revert Initial
  • Create Documentation: https://www.jetbrains.com/help/pycharm/documenting-source-code.html
  • Use // TODO: for Empty Sections
  • Do Not Use Wildcard Imports - Editor > Code Style > Java > Imports > Class count to use import with '*': 99
  • File Names: CamelCase
  • Class Names: CamelCase
  • Interfaces: CamelCase
  • Constant Names: UPPER_SNAKE_CASE
  • Entity Names: CamelCase and singular: firstName
  • PostgreSQL
    • Table Names Postgres: snake_case and plural
    • Column Names: snake_case and singular
  • Last Line of the File Should Be Empty
  • HTTP Status Codes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status#client_error_responses
  • Rest API Naming Conventions/Best Practices
  • Commit Standarts
  • Software Naming Conventions
  • Class icinde DI Objesini private final Mantık:
  • HTTP Status Codes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
  • Timeout
  • Monitoring Integration
  • Logging Integration
  • Backend Always Validation with Second System: Two Factor, Seal Integration, etc. Commit message standarts bunu ekle rutin best practicelere Best practices Create Documentation: https://www.jetbrains.com/help/pycharm/documenting-source-code.html Branch protection Sonarqube best practices Bireysel kafkaesque akısını uygula cok iyi heyecan verici Ai pair programmer, reviewer Business logic içeren, veritabanından bağımsız domain objeleri (DDD'de Aggregate, Value Object): model klasör Entity klaseo, Veritabanı tablolarını temsil eden, JPA anotasyonlarıyla işaretlenmiş sınıflar: Model ekle (entity'ye ek olarak):
  • Karmaşık business logic varsa
  • Clean Architecture/DDD uyguluyorsan
  • Entity'leri anemic tutup business logic'i ayırmak istiyorsan Transaction Entity - Transfer işlemlerini kaydetmek için Audit Log - Tüm işlemlerin izlenebilirliği için Rate Limiting - API güvenliği için Circuit Breaker - Solana network bağlantı hatalarına karşı Caching - Redis ile balance cache Event Sourcing - Wallet işlemleri için Webhook System - Transaction durumu bildirimleri için Multi-signature Support - Kurumsal kullanım için Security Layer - Encryption, key management Monitoring & Metrics - Prometheus, Grafana entegrasyonu Model Repository Layer Service Layer Controller Layer DTO Custom Exception Classes Global Exception Handler Validation Configuration: Security, OpenAPI, etc.

Faz 1: Temel Altyapı (Mevcut) ✅ Wallet oluşturma ✅ Bakiye sorgulama ✅ SOL transferi ✅ Transaction takibi ✅ Devnet airdrop (test için) Faz 2: Güvenlik ve Kullanıcı Yönetimi (Öncelik: Yüksek)

  1. Kullanıcı Kayıt/Login Sistemi
  • JWT tabanlı authentication
  • Şifreli kullanıcı kayıtları
  • Email/password veya Solana wallet ile login
  1. Private Key Güvenliği
  • Private key'leri database'de şifreleyerek saklama (AES-256)
  • Wallet import/export fonksiyonları
  • Mnemonic phrase (seed phrase) desteği
  1. Multi-signature Wallet Desteği
  • Birden fazla imza gerektiren wallet'lar Faz 3: Token Yönetimi (Öncelik: Yüksek)
  1. SPL Token Desteği
  • SPL token bakiyelerini görüntüleme
  • Token transfer işlemleri
  • Token yaratma (mint)
  • Token metadata okuma
  1. NFT İşlemleri
  • NFT listeleme ve görüntüleme
  • NFT transfer
  • NFT metadata ve image fetching Faz 4: Gelişmiş İşlemler
  1. Transaction History
  • Kullanıcının tüm transaction geçmişi
  • Filtreleme ve arama
  • Export (CSV, PDF)
  1. Staking İşlemleri
  • Stake pool listesi
  • SOL staking
  • Rewards hesaplama
  1. DeFi Entegrasyonları
  • Raydium, Orca gibi DEX entegrasyonları
  • Swap işlemleri
  • Liquidity pool işlemleri Faz 5: Kullanıcı Deneyimi
  1. Bildirim Sistemi
  • Transaction bildirimleri
  • Email/SMS uyarıları
  • WebSocket ile real-time updates
  1. Address Book
  • Sık kullanılan adresleri kaydetme
  • Label/tag sistemi
  1. Multi-wallet Support
  • Bir kullanıcı için birden fazla wallet
  • Wallet grupları Faz 6: Analytics ve Raporlama
  1. Portfolio Tracking
  • Token bazlı değer hesaplama
  • USD karşılıkları
  • Grafik ve analitik
  1. Tax Reporting
  • Vergi raporlama için export
  • Kar/zarar hesaplama

Code quality Code sync Code smell Enginering culture Sonarqube Technical dept Code revirew

Claude Code ile Agentlar Paralel Calıstırmak Full AI ile Hızlanmak Merkezde Note

Standards To Be

  • Clean Code
  • SOLID Principles
  • DRY Principle
  • KISS Principle
  • Design Patterns
  • Refactoring
  • TDD
  • Documenting Code
  • Code Review
  • Pair Programming
  • Continuous Integration
  • Continuous Deployment
  • Code Quality
  • Code Coverage
  • Code Analysis
  • Code Smells
  • Code Duplication
  • Code Complexity
  • Code Maintainability
  • Code Reliability
  • Code Testability
  • Code Security
  • Code Style
  • Code Conventions
  • Code Documentation
  • Code Comments
  • Code Formatting
  • Code Linting
  • Use Environment Variables
  • Use Profiling
  • Use Dev Prod Staging Environments
  • Use Custom Response Model
  • Use Comments
  • Use Custom Exceptions
  • Use Pagination

Paytech Links (GitHub, Medium)

About

Paytech Systems

Topics

fintechjavapaytechspringsprint-boot

Resources

Readme
MIT license
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Sponsor this project

Packages

Contributors

Languages