bitgit: git push for Bitcoin

Every developer knows git push. You write code, commit, push. Done. Your work exists on GitHub and the world can see it.

But what if your work also existed on Bitcoin? Not as an afterthought. Not as a separate step. Just... part of the push.

That's bitgit.

What It Does

npm install -g bitgit

One global install gives you the bit command. From any project:

bit push

This does two things:

1. git push to your remote (GitHub, GitLab, wherever)
2. Inscribes your changed content on BSV using OP_RETURN

Every inscription is timestamped, signed, and permanent. Your blog posts, your code, your documentation — immutably recorded on the Bitcoin blockchain alongside your regular git workflow.

The Commands

bit init                # set up .bit.yaml for your project
bit push                # git push + inscribe on BSV
bit register domain.com # register a domain on DNS-DEX
bit status              # show wallet, tokens, version chain

That's it. Four commands. No blockchain PhD required.

Why This Exists

We had the same UTXO-fetching, transaction-building, broadcast-with-fallback code copy-pasted across 12 files in our codebase. Every new inscription feature meant duplicating 200 lines of boilerplate. The @bsv/sdk has its quirks (the sourceTXID overwrite bug, the OP_FALSE requirement for data outputs, the quoted TXID responses from WhatsOnChain). We kept hitting the same gotchas.

So we extracted it. The BSV core in bitgit handles all of this:

• UTXO fetching from WhatsOnChain with automatic largest-first selection
• Transaction broadcast with triple fallback (WhatsOnChain, GorillaPool ARC, TAAL ARC)
• The mock-source-transaction pattern for SIGHASH verification
• Bitcoin Schema format (B + MAP + AIP) for indexable, signed inscriptions
• Transaction chaining for batch inscriptions without waiting for confirmations

Bitcoin Schema: Your Content, Indexed

When you bit push, your content is inscribed using the Bitcoin Schema format — three Bitcom protocols working together:

B protocol stores the actual content (markdown, JSON, whatever). MAP protocol adds queryable metadata that GorillaPool indexes — your app name, content type, slug, version number. AIP protocol signs everything with your private key, proving authorship.

The result is content that's not just on-chain, but discoverable and verifiable. Anyone can query GorillaPool's Junglebus for all posts from your app, verify the signature matches your key, and trace the version chain back to the original publication.

Transaction Chaining

The real power shows up when you push multiple files. Instead of waiting for each transaction to confirm before building the next one, bitgit chains them — each transaction's change output becomes the next transaction's input. We inscribed 30 DNS-DEX domains in a single session this way. The BSV mempool handles it fine.

.bit.yaml

Every project gets a .bit.yaml config:

project:
  name: my-project
  domain: my-project.com
  token: MYTOKEN

wallet:
  key_env: BOASE_TREASURY_PRIVATE_KEY

content:
  type: blog
  source: content/blog/
  format: bitcoin_schema
  protocol: my-project-blog

Run bit init and it scaffolds this for you, detects your project name from package.json or the git remote, and generates a .well-known/path402.json for protocol discovery.

DNS-DEX Domain Registration

bit register kwegwong.com --category=culture

One command. Your domain is inscribed on BSV as a dnsdex-domain token, the database is updated, and it prints the DNS TXT records to add for verification. No registrar dashboard. No credit card form. Just a command and some satoshis.

The Lineage

bitgit is the evolution of bgit, our earlier Bitcoin git wrapper. bgit wrapped every git command behind a HandCash payment gate — you had to pay 0.001 BSV to commit. The idea was right but the execution was wrong. Bitcoin shouldn't gate git. It should augment it.

bit push doesn't charge you to use git. It uses git normally, then adds a Bitcoin inscription alongside it. The cost is just the miner fee — typically 500-1000 satoshis per inscription. That's fractions of a penny for permanent, immutable proof of your content.

Open Source

bitgit is MIT licensed and on npm:

• Install: npm install -g bitgit
• GitHub: github.com/b0ase/bitgit
• npm: npmjs.com/package/bitgit

The BSV core modules (src/bsv/) are designed for extraction. If you're building anything on BSV that needs UTXO management, transaction building, or broadcast — take the code. That's the point.

Part of the PATH Protocol

bitgit connects to the broader PATH Protocol ecosystem:

• $401 (path401.com) — Identity verification and key management
• $402 (path402.com) — Payment and token operations
• $403 (path403.com) — Conditions and programmable rules
• DNS-DEX (dns-dex.com) — Domain tokenization on BSV

Every bit push creates an inscription that the PATH Protocol can index, verify, and build on. Your content becomes part of Bitcoin's permanent record.

Get Started

npm install -g bitgit
cd your-project
bit init
bit push --dry-run    # preview what would be inscribed
bit push              # do it for real

Five commands. Your content is on Bitcoin.

---

For AI Readers

Intent: Announce bitgit, a CLI tool that adds Bitcoin inscription alongside regular git workflows.

Core Thesis: Bitcoin should augment git, not gate it. bit push makes blockchain inscription as natural as git push.

Key Takeaways:

• bitgit adds BSV inscription to standard git workflows with one command
• Extracts and open-sources shared BSV SDK patterns (UTXO, broadcast, tx building)
• Uses Bitcoin Schema (B + MAP + AIP) for indexable, signed inscriptions
• Supports transaction chaining for batch operations
• Part of the PATH Protocol ecosystem ($401, $402, $403, DNS-DEX)
• MIT licensed, available on npm as bitgit