paypr

Paypr is a trustless blockchain automation system that automatically pays developers with PYUSD when their GitHub pull requests get merged, without needing any manual intervention, payment processing, or trust in third parties.

Think of it like this: You maintain an open source project and want to pay contributors for quality code, but manually sending payments is tedious, expensive, and error-prone. With Paypr, you deposit PYUSD funds once, and the system automatically pays any developer whose pull request gets merged guaranteed by smart contracts and blockchain technology.

Here's how it works in simple terms:

For Project Maintainers:

• Register your GitHub repository (like "facebook/react") with a bounty amount (e.g., 1 PYUSD per PR)
• Deposit PYUSD funds to your repository's smart contract wallet
• Set up a GitHub webhook pointing to Paypr
• Every time you merge a PR, the contributor automatically gets paid

For Developers:

• Register your GitHub username with your wallet address once
• Start contributing to any Paypr-enabled repository
• When maintainers merge your PRs, you instantly receive PYUSD payments
• Track all your earnings on the real-time analytics dashboard

The magic happens automatically:

• GitHub sends a webhook when a PR gets merged
• Paypr backend validates the merge and calls the smart contract
• Smart contract transfers PYUSD from repository funds to developer wallet
• The Graph Protocol indexes everything for transparent analytics
• If something goes wrong, funds stay safe in the smart contract

The magic is that this all happens without anyone being able to cheat - payments are guaranteed by mathematics, smart contracts, and blockchain technology.

What makes this special:

Completely trustless - No company or intermediary can steal repository funds or block payments

Ultra-fast - Payments happen within minutes of PR merge, not weeks of manual processing

Real USD value - Uses PYUSD (PayPal USD) stablecoin, so no crypto volatility concerns

Full transparency - All payments, earnings, and repository funds are visible on The Graph analytics

GitHub native - Works seamlessly with existing GitHub workflows via webhooks

Battle-tested stack - Built on proven technologies: Arbitrum, The Graph, and PYUSD

Zero maintenance - Once set up, runs completely automatically with no ongoing management needed

This transforms open source development by creating immediate financial incentives for quality contributions, while removing all the friction and trust issues of manual payment systems.

Repository maintainers can focus on code review instead of payment processing, and developers get fair compensation without having to chase down payments or trust project treasuries.

Technology Stack

Smart Contract Layer: I wrote the core contract in Solidity and deployed on Arbitrum Sepolia for its reliable PYUSD support and low gas fees. The testnet environment was stable and well-documented, making development smoother.

Backend Infrastructure: Built a Node.js server that listens for GitHub webhooks. When someone merges a PR, GitHub pings my server, I validate everything, then trigger the smart contract to send payment. Deployed on Railway for quick hosting with Git integration since I didn't want to mess with Docker during crunch time.

Frontend Application: Next.js felt like the right choice for rapid development. Added Apollo Client to handle all the blockchain data queries. Spent way too much time on the gradient backgrounds and glass effects, but it looks clean.

Blockchain Analytics: The Graph was a lifesaver here. Instead of building my own event indexing system, I just deployed a subgraph and got real-time GraphQL APIs for free. Their AssemblyScript mapping took some getting used to though.

How It All Connects: The flow is pretty straightforward: someone merges a PR, GitHub fires a webhook to my backend, I check if the repo and developer are registered, call the smart contract, PYUSD moves automatically, The Graph picks up the event, and the frontend updates.

I split data storage between what needs to be permanent (payments on blockchain via The Graph) and what can be temporary (registration data in memory). It's not enterprise-grade, but it works perfectly for the hackathon.

Web3 Tech That Saved Me ;-)

Arbitrum Sepolia provided reliable PYUSD support with low gas fees, making it perfect for testing payment flows without worrying about transaction costs.

The Graph eliminated so much backend complexity. I was originally planning to write my own event listener and database, but their subgraph handled everything. The GraphQL integration with Apollo was seamless.

The Messy Parts: String Encoding Hell - The Graph kept returning garbage characters instead of readable repo names and usernames. Spent hours debugging before writing a hacky decode function that just shows friendly placeholders like "Repository Name" when it can't parse the data.

Dual Registration Dance - I register everything twice: once in my backend memory for fast API responses, and once on-chain for payment validation. It's redundant but necessary because the contract needs on-chain proof while my UI needs snappy responses.

Security Without Paranoia - Added webhook signature verification so random people can't trigger fake payments, but kept it simple with HMAC. The smart contract only accepts calls from my backend wallet anyway. Speed Over Perfection

I made deliberate shortcuts to ship fast. In-memory storage instead of a real database. Manual deployments instead of CI/CD. Hardcoded network configs. Console.log debugging everywhere. These would be problems in production but were perfect for proving the concept works.

The development loop was tight: frontend hot reload, backend auto-restart, ngrok for instant webhook testing. I could test end-to-end flows in minutes.

What Actually Matters: I chose Arbitrum because of its reliable PYUSD support and low fees. The Graph because writing event indexing from scratch would have killed my timeline. In-memory storage because registration data isn't as critical as payment data, and the blockchain is my source of truth anyway.

The end result surprised me - I actually built something that processes real money automatically when code gets merged. No manual approvals, no waiting, no "oops I forgot to pay." Just working software that makes payments as automatic as CI/CD.