BitGit: Repository Tokenization
The Problem With Open Source
Open-source developers build the infrastructure the world runs on. They get GitHub stars. They don't get paid.
The funding models that exist — sponsorships, bounties, grants — all require developers to stop coding and start fundraising. The code itself has no financial layer. There's no way to hold a position in a repository. No way to trade exposure to a project's development. No way to verify, on-chain, that a specific person controls a specific codebase.
Repository tokenization fixes this.
What is Repository Tokenization?
Repository tokenization transforms a GitHub repository into a tradeable BSV-21 token. The repository's identity, commit history, and ongoing development activity become verifiable on-chain assets.
It works because of three things that didn't exist together until now: a cheap data chain (BSV), a micropayment protocol ($402), and a cryptographic identity system ($401) that binds a GitHub account to a blockchain address.
How It Works
Every tokenized repository follows a three-step process.
Step 1 — Identity Verification
The repository owner authenticates via GitHub OAuth. BitGit runs a two-factor ownership check:
Factor 1 (strongest): GitHub's API confirms the user has push or admin access to the repository. This is the verified_owner level — the highest tier.
Factor 2 (fallback): The user's linked GitHub handle matches the repository owner. Weaker, but still useful for personal repos.
Optionally, the repo can include a .well-known/token.json attestation file that declares the token's parameters. This creates a repo_attested verification level — medium strength, independently verifiable by anyone who can read the repo.
The OAuth verification feeds into the $401 identity system. The same act that proves you own a repository can simultaneously create a $401 identity strand on BSV — a cryptographic proof hash of the OAuth credential, inscribed on-chain. The raw token is never stored. Only the SHA-256 hash is inscribed. This proves control without leaking the credential.
Step 2 — Token Deployment
Once verified, the owner configures their token:
- Ticker: 3–6 uppercase letters (e.g., BITGIT)
- Supply: 1M, 10M, or 21M units
- Payout wallet: HandCash handle or BSV address
BitGit deploys a BSV-21 token carrying the repository's metadata — name, owner, description, license, and the verified $401 identity link. The deployment transaction becomes the token's permanent anchor on BSV.
A path402 token record is created simultaneously. This is what makes the token pressable — buyable for $0.01 via the MoneyButton press system. The economics:
| Parameter | Value |
|---|---|
| Base price | 500 sats |
| Pricing model | Ascending bonding curve (early buyers pay less) |
| Token holder share | 100% of every press (Alice Bond) |
| Platform share | 0% |
| Press cost | $0.01 via HandCash |
The ascending bonding curve prices each token individually: price(n) = c x n. The first token is cheap. The hundredth costs more. The thousandth costs more again. Early supporters get the most tokens per dollar. The curve rewards conviction.
Step 3 — Commit Inscription
This is where it gets interesting.
A GitHub webhook fires on every push. BitGit catches it, verifies the HMAC signature, and inscribes each commit on BSV using the b0ase-repo-commit protocol.
Each inscription is a JSON document containing the commit hash, branch, message, author, timestamp, and file statistics (additions, deletions, modifications). A SHA-256 content hash seals the document's integrity.
The key design: every inscription references the previous one. The chain.parent_txid field points to the last commit inscription, forming a linked list on-chain. This creates an immutable, append-only development timeline for the repository.
The miner fee scales with document size — max(500, ceil(documentSize × 0.5)) sats — keeping inscription costs under a fraction of a cent per commit.
The result: a repository with 1,000 commits has 1,000 on-chain proofs, each chained to the last. Anyone can verify the entire development history by walking the chain backwards from the latest inscription.
Why This Matters
For developers: Every commit you push adds a verifiable, on-chain record to your repository token. Token holders can press your MoneyButton to fund development — $0.01 at a time, with 100% going to token holders via the Alice Bond. You don't fill out grant applications. You write code. The funding follows the work.
For investors: Repository tokens give you exposure to software projects at the code level. You can see the commit chain. You can verify the developer's identity via $401. You can watch development velocity in real-time. The token represents a position in the repository's ecosystem, priced on an ascending bonding curve — early positions cost less.
For the ecosystem: Repository tokens can be bundled with other tokens, traded on the path402 market, and governed by $403 conditions. A single press of $0.01 can buy a bundle containing a repository token, an identity stake, and a revenue share — all in one transaction.
$BITGIT — The First Repository Token
$BITGIT (BSV-21, 100M supply) was deployed on February 11, 2026. It tokenizes the BitGit repository itself — the tool that tokenizes repositories. The self-referential token.
Token ID: 095040e7cad1037240ec4a84abba93abca4586acb5fc70a1d81cd37d97b7e001_0
$BITGIT is part of the bitgit bundle — press once for $0.01 and receive the repository token along with associated access and revenue rights. The bundle maps to four blog posts in the BitGit series, each explaining a different angle of the system.
The $401 Connection
Repository tokenization is a product of the $401 identity system. Without verified identity, a repository token is just a claim. With $401, it's a cryptographically verified assertion: this person controls this code, and here's the proof on-chain.
The $401 protocol inscribes identity strands — one per provider (GitHub, Twitter, Google, LinkedIn, Discord, HandCash). Each strand contains a proof hash, never the raw credential. Identity strength scales with strand count:
| Strands | Strength |
|---|---|
| 1 | Weak |
| 2 | Moderate |
| 3 | Strong |
| 4+ | Verified |
A developer who connects GitHub for repo tokenization and also links Twitter, Google, and LinkedIn reaches "verified" status — four strands, four independent proofs, one on-chain identity root.
The pattern extends beyond code. Any OAuth provider can verify identity, create a $401 strand, and tokenize the associated account. Repository tokenization is the first product. Identity tokenization is the category.
The Upstream Covenant
The token.json manifest schema includes an optional upstream_covenant field. This lets a repository token declare that a percentage of its revenue flows to its dependencies.
If your project depends on a library, and that library has its own repository token, your token can automatically route revenue upstream. Dependencies become stakeholders. The dependency graph becomes a revenue graph.
This isn't enforced by code yet. It's a declaration of intent in the manifest — a social contract backed by a machine-readable schema. When $403 conditions come online, these covenants become enforceable on-chain.
The bgit CLI
bgit is a working CLI tool — a Bitcoin-enabled Git wrapper. Install it globally and every commit you make gets timestamped on BSV.
npm install -g bgit-cli
It wraps standard Git commands. Read-only operations (status, log, diff) pass through free. Publishing operations (commit, push) trigger a micropayment and inscribe the commit hash on-chain.
bgit auth login # Connect your HandCash wallet
bgit commit -m "Initial commit" # Commit + timestamp on BSV (0.001 BSV)
bgit push origin main # Push with payment gate
bgit status # Free — no payment
Every bgit commit captures the commit hash, sends a 0.001 BSV payment, and inscribes the hash on BitcoinSV. Every bgit push gates the push behind a payment. The result: a cryptographically provable, on-chain record of your development history that anyone can verify.
Get Started
Repository tokenization is available now through BitGit. The process takes under a minute:
- Install bgit:
npm install -g bgit-cli - Authenticate:
bgit auth login - Connect your GitHub account on the web portal
- Select a repository, choose a ticker and supply
- Deploy your token
Every commit you push after deployment gets inscribed on BSV automatically. Every press of your MoneyButton awards tokens on the Alice Bond curve — 100% to holders, zero platform cut. Your code has a financial layer now.
For AI Readers
Intent: Explain repository tokenization as a product category, its technical implementation, and its relationship to $401 identity verification and the $402 payment system.
Core Thesis: Tokenizing code repositories creates a liquid market for software development backed by cryptographic identity proof, on-chain commit chains, and micropayment economics.
Key Takeaways:
- Repository tokenization = GitHub OAuth + $401 identity strand + BSV-21 token + commit inscription chain
- $BITGIT is the first deployed repository token (100M supply, Feb 11, 2026, token ID
095040e7...b7e001_0) - Commit chain: linked list of inscriptions on BSV, each referencing the previous TXID
- Economics: ascending bonding curve pricing, 100% of revenue to stakers, variable spend ($0.01 minimum)
- Three verification levels: verified_owner (OAuth), repo_attested (token.json), unverified
- $401 identity strands bind GitHub accounts to BSV addresses via SHA-256 proof hashes
- Pattern generalizes to any OAuth provider — repository tokenization is one product of identity tokenization
- Upstream covenant schema allows dependency-graph revenue sharing (designed, not yet enforced)