MERGE PROTOCOL

Merge Protocol is the execution layer for professional Web3 gigs. We replace Web2 corporate middlemen with immutable smart contracts, combining trustless escrow, UI-assisted GitHub verification, and end-to-end encrypted chat to create a frictionless freelance economy on Arbitrum.

⚠️ The Problem

Trusting a stranger on the internet with your codebase or your treasury is a liability. Traditional freelance platforms solve this by acting as a centralized middleman, extracting 20% of your payout and locking you into walled gardens. In Web3, sending tokens to a dev you just met on Discord is a massive risk. The ecosystem needs a trustless standard for gig work.

💡 The Solution: Merge Protocol

We built an operating system for decentralized work. Merge Protocol ensures that clients feel safe funding a project, and developers know they will actually get paid when they ship. No middlemen. No exorbitant fees. Just code and execution.

Key Features:

• Trustless Escrow: Client funds are locked securely in an Arbitrum smart contract. If the code ships, the funds release.

• Cryptographic Proof of Work: We built a UI-assisted GitHub integration that queries the API to verify if a Pull Request has been successfully merged, giving clients the cryptographic green light to release funds. Don't trust. Verify.

• Decentralized Negotiation: Web3 workers value privacy. We integrated XMTP to provide end-to-end encrypted, wallet-to-wallet chat directly in the dashboard. Clients and freelancers can securely share private repo links and negotiate terms without ever doxxing their identities.

• Built-in Arbitration: A decentralized dispute resolution role allows a neutral third-party Arbiter to step in, review submitted evidence, and route the funds fairly if a gig goes sideways.

🛠️ The Tech Stack

• Network: Arbitrum (Fast, cheap, L2 execution)

• Smart Contracts: Solidity, Hardhat, Wagmi/Viem

• Frontend: Next.js, Tailwind CSS, DaisyUI

• Realtime/DB: Supabase

• Communications: XMTP Browser SDK (V3)

Ship code. Get paid. Welcome to the new standard

🧗‍♂️ Progress & Challenges During the Hackathon

Building a fully on-chain freelance marketplace in under two weeks was an intense sprint. We wanted to build something that didn't just look good, but actually functioned as a trustless Web3 primitive. Here are the major hurdles we overcame:

1. The Oracle Dilemma: Verifying GitHub PRs

• The Challenge: We needed our smart contracts to know if a freelancer actually merged their code on GitHub before releasing escrowed funds. Initially, we looked at setting up a backend relayer with a private key to trigger state changes, or using complex decentralized oracles.

• The Pivot: We realized managing a hot wallet private key for a backend bot is a massive security risk (and a classic point of failure for live demos). Instead, we built a UI-assisted verification flow. The Next.js frontend directly queries the public GitHub API. If the PR is merged, the UI gives the Client a cryptographic "Green Light" to safely sign the transaction and release the funds themselves. It degrades gracefully and removes central points of failure.

2. Decentralized Privacy: The XMTP Integration

• The Challenge: Freelancers and clients need to share private repository links, API keys, and negotiate terms. Doing this publicly defeats the purpose, and relying on Web2 chat platforms breaks the Web3 ethos.

• The Solution: We integrated the XMTP Browser SDK for end-to-end encrypted, wallet-to-wallet chat. But we ran into a strategic UX challenge: How does the Arbiter fit in? Instead of building a messy 3-way group chat, we engineered a custom "Chat Switcher" hook. We deliberately kept the Arbiter locked out of the initial Client/Freelancer chat to preserve a "Safe Space" for negotiation. The Arbiter only gets context if a dispute is officially raised and evidence is submitted.

3. Battling Arbitrum's Sequencer (The 3 AM Gas Spikes)

• The Challenge: While testing our contract calls on localhost with MetaMask, transactions would randomly revert with: max fee per gas less than block base fee.

• The Solution: We learned a valuable lesson about Layer 2 architecture! Because Arbitrum is so fast, its sequencer updates the baseFee dynamically based on L1 data costs. In the split second between our Wagmi hook estimating the gas and MetaMask signing it, the base fee would shift. We bypassed this by managing gas buffer configurations and manually handling aggressive gas estimations to ensure smooth execution on the Arbitrum network.