PassportX — Stellar-Native Cross-Border Identity and KYC Attestation Layer

Privacy-preserving, reusable KYC attestation protocol built on Soroban.
Complete identity verification once with a licensed Stellar Anchor and receive a non-transferable on-chain credential (Soulbound-like) that encodes your verification tier. Downstream dApps, anchors, and payment corridors query the credential on-chain — no repeated full KYC required.

PassportX eliminates one of the biggest friction points in the Stellar payments ecosystem: duplicated KYC across every anchor and corridor. It uses zero-knowledge proof primitives for selective disclosure, allowing users to prove they meet a required threshold (e.g., "KYC Tier 2 + Sanctions Passed") without exposing underlying personal data.

✨ Features

• One-Time KYC — Verify with a trusted licensed Anchor; reuse everywhere on Stellar.
• Privacy by Design — Zero-knowledge selective disclosure. Prove attributes without revealing data.
• Non-Transferable Credentials — Soulbound / non-transferable on-chain attestations.
• On-Chain Gating — dApps and services query credentials directly via Soroban for access control.
• Tiered Verification — Support for multiple KYC tiers (Basic, Enhanced, Institutional, etc.).
• Cross-Border Ready — Designed for payment corridors, remittances, and global DeFi on Stellar.
• Auditable & Compliant — Built to support regulatory requirements while maximizing user privacy.
• Soroban Native — Fully leveraging Stellar's smart contract platform for low-cost, high-speed verification.

🚀 Use Cases

• Payment Corridors — Gate cross-border transfers based on verified KYC tier without re-verification.
• Decentralized Exchanges & DeFi — Require proof of KYC for certain trading pairs or higher limits.
• Anchors & On/Off-Ramps — Streamline user onboarding across multiple services.
• Remittance Apps — Reduce friction for users moving value across borders.
• DAO & Governance — Selective proof of personhood or accreditation without full data exposure.
• Any Soroban dApp — Query PassportX credential before executing sensitive operations.

Getting Started Prerequisites Rust (stable + nightly for Soroban) Stellar CLI (stellar command) Node.js (for frontend/demo, if applicable) Funded testnet/futurenet account (use Stellar Laboratory)

Installation

Clone the repository

git clone https://github.com/yourusername/passportx.git cd passportx

Build all contracts

cargo build --release

Or use Stellar CLI for convenience

stellar contract build

Testing

Run unit tests

cargo test

Run Soroban-specific tests

cd contracts/passportx-core cargo test --test test

Deployment (Testnet)

Deploy the core contract

stellar contract deploy
--wasm target/wasm32-unknown-unknown/release/passportx_core.wasm
--network testnet
--source <YOUR_SECRET_KEY>

Initialize the contract (set admin, anchor issuers, etc.)

stellar contract invoke
--id <CONTRACT_ID>
--network testnet
--source <YOUR_SECRET_KEY>
-- initialize --admin <ADMIN_ADDRESS> ...

See scripts/deploy.sh for automated deployment flows. How It WorksUser Verification — User completes KYC with a licensed Stellar Anchor (off-chain). Credential Issuance — Anchor calls the PassportX contract to mint a non-transferable credential encoding the verification tier + metadata hash. Zero-Knowledge Proofs — Users generate ZK proofs off-chain to selectively disclose attributes (e.g., "age > 18", "not on sanctions list", "KYC tier ≥ 2"). On-Chain Verification — Any contract or dApp invokes the verifier function with the proof and public inputs. The contract checks validity without seeing private data. Access Gating — Downstream logic gates functionality based on successful proof verification.

The protocol is designed to be modular — anchors act as trusted issuers, while the on-chain layer handles verification and non-transferability. Integration GuideFor dApps / Soroban Contractsrust

// Example: Check if user has valid KYC Tier 2 let has_valid_kyc = passportx_contract.verify_credential( &env, user_address, tier_threshold: 2, proof: &zk_proof, public_inputs: &vec![...] );

For Frontend (JavaScript/TypeScript)Use the generated Soroban bindings or @stellar/soroban-client.Example integration coming soon in /frontend. Security & AuditsAll contracts follow Soroban best practices. Zero-knowledge components leverage Stellar's native ZK-friendly primitives (BN254, Poseidon, etc.) where available. Planned: Third-party security audit (recommended before mainnet). We welcome responsible disclosure — see SECURITY.md.

Important: Smart contracts involve financial and identity risk. Use at your own risk. Always test thoroughly on testnet. LicenseThis project is licensed under the Apache License 2.0 — see the LICENSE file for details. Contributing We welcome contributions from the Stellar community! Fork the repo Create a feature branch (git checkout -b feature/amazing-idea) Commit your changes (git commit -m 'Add amazing feature') Push to the branch (git push origin feature/amazing-idea) Open a Pull Request

Please read CONTRIBUTING.md for details on our code of conduct and development process. Support & Community Discord: Join the Stellar Developer Discord and look for the PassportX channel (or create one!). Issues: GitHub Issues Discussions: Use GitHub Discussions for questions and ideas. Twitter/X: Follow updates or tag @yourhandle

Acknowledgements Built on Soroban — Stellar's smart contract platform. Inspired by the need for better identity infrastructure in the Stellar ecosystem. Thanks to the Stellar Development Foundation, Soroban core team, and the broader blockchain privacy community.

PassportX — One verification. Infinite reuse. Maximum privacy.Made with for the Stellar ecosystem.This README is a living document. Contributions to improve documentation are highly appreciated!