How GitSponsor works.

GitSponsor connects onchain trading fees to GitHub developer funding. Anyone can launch a token on pump.fun through GitSponsor and name one GitHub developer as its fee recipient. From then on, the creator fees that coin earns are collected every hour, converted to a dollar amount, and sent to that developer as a one-time GitHub Sponsorship.

The developer does not need a wallet, does not need to know about crypto, and does not need to claim anything. They only need what they already have: an account that GitHub has approved for Sponsors.

The system has four moving parts, and only one of them is new.

• pump.fun — the launchpad and bonding curve. Coins created through GitSponsor are ordinary pump.fun coins: same supply, same curve, same graduation to PumpSwap.
• Creator fees — pump.fun pays the coin's creator a share of every trade. GitSponsor sets that creator to a key it controls, dedicated to the coin.
• GitHub Sponsors — the payout rail. GitSponsor sponsors developers the same way any GitHub user does, using one-time sponsorships.
• GitSponsor — the glue: a directory, a launch flow, an hourly collector and a public ledger.

1. Create. A launcher connects a Solana wallet, uploads a logo, names the coin and picks a developer from the sponsorable directory. GitSponsor pins the metadata to IPFS and builds a pump.fun createV2 + buy transaction. The launcher signs and pays for it.
2. Fee creator. In that transaction the coin's creator field is set to a key derived by GitSponsor for this mint only. Every coin has its own creator, so every coin has its own fee vault. Nothing has to be indexed or attributed later.
3. Trade. Buys and sells on the bonding curve pay pump.fun's creator fee into the vault. After graduation, PumpSwap trades pay it into the AMM creator vault for the same key.
4. Collect. On the hour, GitSponsor sweeps each vault that holds at least 0.01 SOL into the treasury and records the amount together with the SOL/USD price at that moment.
5. Sponsor. Collections are grouped per developer. Once a developer's unpaid balance reaches $1 (GitHub's one-time minimum), GitSponsor pays a one-time GitHub Sponsorship for the whole dollar amount with the GitSponsor card and marks the payout as sent.

create token ─► pick developer ─► trades pay creator fee
                                        │
                        hourly sweep ◄──┘  (per-token vault → treasury, booked in USD)
                                        │
                     GitHub Sponsors ◄──┘  one-time sponsorship to the developer

The recipient directory is not curated by GitSponsor. It is GitHub's own list of accounts that have been approved for GitHub Sponsors, reachable at github.com/search?q=is:sponsorable&type=Users.

Search on the create page queries that list live. Eligibility is checked again server-side at launch time; a login that is not sponsorable is rejected before any transaction is built.

What GitSponsor stores

Only the public GitHub login (plus a cached copy of the public name, avatar, bio and follower count for display). No contact details, no payment details — GitHub holds those.

Immutability

The recipient is part of the token's record and cannot be changed by the launcher, the developer or GitSponsor after creation.

GitSponsor does not add a tax on top of pump.fun. The “tax” that funds developers is pump.fun's native creator fee, which pump.fun pays out of its protocol fee on every trade. Whatever pump.fun's current creator-fee schedule pays, the coin's vault receives.

This is the part that makes the whole thing work, so it is worth being exact. GitSponsor never touches the trade, the pool or the token supply. It receives the fee because it is, in pump.fun's eyes, the coin's creator.

1 · pump.fun pays a creator on every trade

Every pump.fun coin has a creator field stored on its bonding-curve account. On each buy and sell the program splits its trading fee: one part to pump.fun's protocol fee accounts, one part to a creator_vault — a program-derived account (PDA) seeded by that creator's public key. After the coin graduates, PumpSwap keeps paying the creator share into a matching vault for the same key. Only a transaction signed by the creator key can withdraw from either vault (collect_creator_fee).

2 · GitSponsor sets the creator to a key it controls

When you launch through GitSponsor, the createV2 instruction is built server-side with the creator argument set to a fresh key that GitSponsor derives for that mint:

fee_creator(mint) = Keypair( HMAC-SHA256( treasury_secret, mint ) )

The creator is a plain public key argument — it does not have to sign the create transaction. Your wallet signs and pays; the mint keypair signs; the creator is simply recorded on the curve. The derived secret is never stored anywhere: it is recomputed from the treasury secret whenever it is needed, and it is unique per coin, so every token has its own isolated vault and its fees can never be confused with another token's.

3 · The launch is verified before it is listed

After the wallet returns the signed transaction, GitSponsor broadcasts it and reads the new bonding curve back from chain. The token only becomes live if bondingCurve.creator equals the key GitSponsor derived. A transaction that was modified to point the creator anywhere else is discarded.

4 · Nobody else can redirect it

• The launcher never holds the creator key, so they cannot collect the fee themselves.
• pump.fun exposes no user-callable way to change a coin's creator after creation.
• The developer's GitHub login is bound to the mint in GitSponsor's record at the same moment, and is read-only from then on.

5 · The hourly sweep

Once an hour GitSponsor reads each token's vault balance. For every vault above the threshold it sends one transaction, co-signed by the treasury (payer) and the derived creator key:

collect_creator_fee(creator = fee_creator)      // vault → fee_creator account
[collect_coin_creator_fee + close wSOL ATA]     // PumpSwap vault, graduated coins only
system_transfer(fee_creator → treasury, all)    // sweep, leaves the derived account empty

The signature is stored and shown on the token page, and the SOL amount is booked in USD at that moment. From here on the money is off-chain, and the rest of these docs describe what happens to it.

The collector runs at minute zero of every hour. Each run is idempotent and fully logged on the token page.

Per token

• Read the vault balances for the coin's fee creator in both pump programs.
• Skip if the total is below the collection threshold.
• Send one transaction that collects the fees and forwards them to the treasury. The transaction signature is stored and linked.
• Book the amount in SOL and USD.

Per developer

• Sum every collection not yet assigned to a payout, across all of that developer's tokens.
• If the sum is at least $1, open a payout for the floored dollar amount.
• Pay it as a one-time GitHub Sponsorship from the GitSponsor account, charged to the GitSponsor card. GitHub settles it to the developer through their existing Sponsors payout (Stripe Connect), exactly like any other sponsorship they receive.
• Record the result: sent with the payment reference, or failed with the reason (retried next hour).

How the card is funded

Collected SOL sits in the treasury; the sponsorship is paid in fiat from the GitSponsor card. Treasury SOL is sold to top the card up, so the developer receives the booked USD amount regardless of what SOL does between collection and payment. The card, not the chain, is the payment rail GitHub sees.

Because payouts are grouped per developer, several small tokens sponsoring the same person add up instead of each waiting for the minimum alone.

You need a Solana wallet with enough SOL for pump.fun's create fee and your optional initial buy. You do not need a GitHub account.

• Pick the developer first. Their profile appears on your token card and page; make it someone whose work the community recognises.
• Logo, name, ticker and description are pinned to IPFS and are permanent.
• The initial buy is executed in the same transaction as creation, ahead of anyone else.
• You receive the tokens you buy. You do not receive creator fees — they belong to the developer by design.

If you are enrolled in GitHub Sponsors you are already eligible. There is nothing to sign up for, connect or claim.

• Sponsorships arrive as ordinary one-time GitHub Sponsorships from the GitSponsor account, paid by card, and show up in your Sponsors dashboard and payouts like any other.
• The developers page and each token page show what has been collected and sent for you, with links to the onchain transactions.
• If you would rather not be a recipient, email or DM @GitSponsor and we will exclude your login from the directory search.

Be precise about what is trustless and what is not.

Onchain, verifiable

• Token creation, the fee-creator key on the curve, fee accrual, and every collection transaction are public on Solana.
• The token page links the mint, the fee creator, the launcher and each collection signature.

Off-chain, trusted

• The hourly sweep from vault to treasury is executed by GitSponsor's keys.
• The conversion to dollars and the card-paid GitHub Sponsorship happen off-chain. GitSponsor publishes both sides so anyone can reconcile collected SOL against sent sponsorships.

Treasury: AYg9Ry…rcCPRn.

GitSponsor is not affiliated with GitHub or pump.fun. Tokens are speculative; their price can go to zero and most do. The only thing GitSponsor promises is where the creator fees go.

Read-only JSON endpoints behind the site. No key required; cached for 15 seconds.

Does the developer have to do anything?

No. Being enrolled in GitHub Sponsors is the whole requirement.

Can I sponsor an organisation?

Not yet. The directory search is limited to user accounts; organisations with a Sponsors listing may be added later.

Who pays the network fees for collection?

GitSponsor. Collections are batched into one transaction per token per hour to keep this negligible.

How is the developer actually paid?

By card. GitSponsor sponsors them on GitHub Sponsors as a one-time sponsorship; GitHub then pays the developer through the Sponsors payout they already have set up. No crypto ever reaches the developer.

What if GitHub rejects a sponsorship?

The payout is marked failed with the reason and retried on the next run. Funds stay booked to that developer.

What happens after the coin graduates?

Nothing changes for the developer. Creator fees continue on PumpSwap and are collected from the AMM vault by the same key.

Can the recipient be changed?

No. It is fixed at creation and shown on every card and page.