( 01 )
Introduction
Degit Network is an open-source reward protocol that connects GitHub activity to onchain value. We believe the developers who power the internet should be directly compensated for their contributions — transparently, trustlessly, and without middlemen.
With Degit, anyone can lock DGN tokens as a bounty on any public GitHub issue. Developers browse open bounties, claim the ones they want to work on, and earn DGN automatically when their pull request is merged. Every step is verifiable onchain.
Degit is live in open beta on Solana mainnet. The protocol is fully operational — bounties can be posted, claimed, and paid out today. The DGN token and the on-chain bounty program launch together at TGE, at which point all beta activity migrates to the production deployment and the full protocol becomes available to everyone.
Whether you are a developer looking to monetize your contributions or a project maintainer who wants to accelerate issue resolution, Degit provides the infrastructure to make open-source collaboration economically sustainable.
( 02 )
How It Works
The Degit protocol operates in four discrete steps. Each step is transparent and verifiable — from the moment a bounty is posted to the moment DGN lands in a developer's wallet.
01
Post
A project owner or community member finds a GitHub issue and posts a bounty. DGN is locked in a smart contract at the time of posting. The higher the reward, the higher the signal — developers prioritize high-value bounties.
02
Claim
Developers browse the Degit bounty board and claim the issues they want to work on. Claiming reserves the bounty for the claiming wallet for a defined window. If the PR is not submitted in time, the bounty returns to open status.
03
Fix
The developer submits a pull request to the linked GitHub repository. The PR must reference the bounty ID in its description. Degit periodically queries the GitHub API to check the status of open bounty PRs.
04
Earn
Once the PR is merged by the repository maintainer, Degit detects it on the next check cycle and triggers payout. Anyone can also submit a payout request manually — Degit verifies the merge via the GitHub API and releases DGN directly to the developer's wallet.
( 03 )
For Contributors
As a developer, Degit lets you turn your open-source contributions into direct income. Here is how to get started:
01
Connect your wallet
Visit degit.network and connect a Solana-compatible wallet (Phantom, Backpack, Solflare, and more are supported). Your wallet address is your identity on the protocol.
02
Link your GitHub account
Navigate to the Link GitHub page and authorize Degit to read your GitHub profile. This step is required to verify PR authorship at payout time. We only request read-only access.
03
Browse open bounties
Visit the Bounties page to see all open bounties sorted by reward size, recency, and technology. Filter by language, label, or repository to find issues that match your skills.
04
Claim and submit
Click Claim on any open bounty to reserve it. Open a pull request on the linked GitHub repository, reference the bounty in your PR body, and get it merged. DGN will arrive in your wallet automatically.
PR Format
Include Degit-Bounty: #BOUNTY_ID anywhere in your PR description to link it to the bounty. Without this tag, automatic payout cannot be triggered.
( 04 )
For Maintainers
As a project maintainer or community member, you can use Degit to attract quality contributors to your GitHub repository by funding bounties on your open issues.
01
Connect and fund
Connect your Solana wallet. Ensure you hold DGN tokens — these are locked as the bounty reward when you post. You can acquire DGN on supported DEXes.
02
Post a bounty
Navigate to Post Bounty, paste the GitHub issue URL, set the DGN reward amount, and confirm the transaction. DGN is locked in the protocol's escrow contract immediately.
03
Watch contributors engage
Your issue will appear on the Degit bounty board. Developers will find it, claim it, and submit pull requests. You review and merge PRs as you normally would on GitHub — Degit handles the rest.
04
Manage your bounties
Track all bounties you have posted from your Dashboard. You can view claim status, see who is working on an issue, and cancel unclaimed bounties to reclaim your DGN at any time.
Payout
Degit runs periodic checks against the GitHub API to detect merged PRs. No action is required from maintainers after merging — payout is automatic. Anyone can also trigger a payout request manually once a PR is merged.
( 05 )
DGN Token
DGN is the native utility token of the Degit Network. It is the currency of the bounty economy — used to fund bounties, pay contributors, and align incentives across the protocol.
| Property | Detail |
|---|---|
Network | Solana |
Symbol | DGN |
Standard | SPL Token |
Use Case | Bounty escrow, contributor rewards |
Transferability | Fully transferable |
Bounty Escrow
Locked at Post
When a bounty is posted, DGN is locked in the protocol's escrow contract. Funds cannot be withdrawn while the bounty is active and claimed.
Contributor Reward
Released at Merge
On a successful PR merge, the escrowed DGN is released directly to the contributor's wallet in a single on-chain transaction.
Cancellation
Refundable
If no developer claims a bounty, or if a claim expires, the bounty poster can cancel and reclaim their DGN at any time.
Protocol Fee
Minimal & Transparent
A small protocol fee is deducted from each payout. Fee parameters are set by governance and are fully visible onchain.
( 06 )
Smart Contracts
Degit's protocol logic lives in an Anchor program deployed on Solana. All escrow, claim management, payout, and cancellation logic is enforced on-chain — no trusted third party can move funds without a valid signed program instruction.
The program deploys to mainnet within 72 hours of the DGN token generation event. From that moment, every bounty posted through the Degit interface interacts directly with the on-chain program, and all payouts are fully trustless.
01
Global Config
A singleton PDA initialised once by the deployer. It stores the fee recipient wallet, the protocol fee in basis points, and the default claim window. All bounty accounts inherit these parameters at post time.
02
Bounty State
Each bounty is stored in a dedicated PDA whose address is derived from the bounty UUID. The account holds the poster, claimant, reward amount, GitHub issue URL, lifecycle status, and claim timestamps.
03
Escrow Vault
DGN is held in a token account PDA whose authority is the bounty state account itself. No individual wallet — including Degit's own — can move funds from escrow without executing a valid program instruction.
04
Claim Management
The claim instruction assigns a developer to a bounty and starts the claim window clock. If the window expires before a PR is merged, any developer may overwrite the stale claim. Claimants may also release voluntarily.
05
Payout Authority
The Degit relay server holds a keypair registered as the payout_authority on each bounty. A cron job periodically queries the GitHub API to check the merge status of claimed PRs. Anyone can also submit a manual payout request — the server verifies the merge against the GitHub API, then submits the complete_bounty instruction. The program deducts the protocol fee and releases the remainder to the developer in a single atomic transaction.
Open Source
The full program source is available at github.com/Degit-Network/degit-bounty. The program deploys to mainnet within 72 hours of DGN TGE, at which point the program ID below becomes the canonical on-chain address for all bounty activity.
// BountyState — on-chain account for a single bounty
pub struct BountyState {
pub bounty_id: [u8; 32], // unique UUID (deterministic)
pub issue_url: [u8; 128], // GitHub issue URL, zero-padded
pub poster: Pubkey, // wallet that posted the bounty
pub claimant: Option<Pubkey>, // active claimant, if any
pub payout_authority: Pubkey, // Degit relay server keypair
pub amount: u64, // DGN locked in escrow
pub status: BountyStatus, // Open | Claimed | Completed | Cancelled
pub claimed_at: i64, // unix timestamp of current claim
pub claim_window: i64, // seconds before claim expires
}
// Instructions
// initialize(fee_bps, claim_window) — deployer only, one-time setup
// post_bounty(bounty_id, issue_url, amount)
// claim_bounty()
// release_claim()
// complete_bounty() — payout_authority only
// cancel_bounty() — poster or payout_authority( 07 )
FAQ
Q
Do I need to hold DGN to contribute?
No. As a developer claiming bounties, you do not need to hold DGN — you earn it. Only bounty posters need DGN to fund a bounty.
Q
What happens if my PR is not merged?
If your PR is closed without merging, the bounty returns to open status after the claim window expires. Another developer can then claim it. You receive no DGN for unmerged work.
Q
Can anyone post a bounty on any repository?
Yes. Degit is permissionless. Anyone can post a bounty on any public GitHub issue, regardless of whether they own the repository. You do not need to be a maintainer to fund open-source work.
Q
How does Degit verify a PR was merged?
Degit runs scheduled cron jobs that query the GitHub API to check the status of all open bounty PRs. When a merge is detected, the relay server submits a payout instruction to the Solana program. Anyone can also trigger a manual payout request — the server re-verifies the merge via the GitHub API before releasing any funds.
Q
Is Degit audited?
The protocol is in open beta. The on-chain program deploys to mainnet within 72 hours of DGN TGE, at which point a formal third-party audit report will accompany the release. All contract source code is open and available for community review at github.com/Degit-Network/degit-bounty.
Q
What wallets are supported?
Any Solana wallet that supports the Wallet Standard is compatible, including Phantom, Backpack, Solflare, and Coinbase Wallet.
Q
How do I get DGN?
DGN launches at TGE and will be available on Solana DEXes immediately after. The on-chain bounty program deploys within 72 hours of TGE. Follow @Degitnetwork on X for the official contract address, launch date, and DEX listings.