bitgit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 b0ase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# bitgit
+
+**`git push` for Bitcoin.** Inscribe content, register domains, and manage tokens on BSV.
+
+```
+npm install -g bitgit
+```
+
+## Commands
+
+```bash
+bit init                # scaffold .bit.yaml for your project
+bit push                # git push + inscribe changed content on BSV
+bit register <domain>   # inscribe a domain on DNS-DEX
+bit status              # show wallet, domain, token & version chain
+```
+
+## Quick Start
+
+```bash
+# 1. Set up your project
+cd your-project
+bit init
+
+# 2. Configure your BSV key
+export BOASE_TREASURY_PRIVATE_KEY="your-wif-key"
+
+# 3. Push content to Bitcoin
+bit push
+```
+
+`bit push` does two things:
+1. `git push` to your remote (if there are commits to push)
+2. Inscribes changed content on BSV (OP_RETURN with Bitcoin Schema)
+
+Every inscription is chained — each transaction's change output feeds the next input, so you can inscribe dozens of files in one session without waiting for confirmations.
+
+## .bit.yaml
+
+`bit init` creates a `.bit.yaml` in your project root:
+
+```yaml
+project:
+  name: my-project
+  domain: my-project.com
+  token: MYTOKEN
+
+wallet:
+  key_env: BOASE_TREASURY_PRIVATE_KEY
+
+content:
+  type: blog              # blog | repo | domain | custom
+  source: content/blog/   # directory to watch
+  format: bitcoin_schema  # bitcoin_schema | op_return
+  protocol: my-project-blog
+
+db:
+  supabase_url_env: NEXT_PUBLIC_SUPABASE_URL
+  supabase_key_env: SUPABASE_SERVICE_ROLE_KEY
+  version_table: blog_post_versions
+
+dns_dex:
+  token_symbol: $my-project.com
+```
+
+## Inscription Formats
+
+### Bitcoin Schema (default)
+
+Uses the B + MAP + AIP Bitcom protocols:
+- **B** — content storage (full markdown/JSON)
+- **MAP** — queryable metadata (indexed by GorillaPool)
+- **AIP** — cryptographic authorship proof (ECDSA signature)
+
+### Simple OP_RETURN
+
+`OP_FALSE OP_RETURN <protocol> <content-type> <payload>`
+
+## DNS-DEX Domain Registration
+
+```bash
+bit register kwegwong.com
+bit register kwegwong.com --category=culture --supply=1000000000
+```
+
+Inscribes a `dnsdex-domain` token on BSV and prints the DNS TXT records to add for verification.
+
+## Broadcast Fallback Chain
+
+Transactions are broadcast with automatic fallback:
+1. WhatsOnChain API
+2. GorillaPool ARC
+3. TAAL ARC
+
+## Dry Run
+
+All commands support `--dry-run` to preview without broadcasting:
+
+```bash
+bit push --dry-run
+bit register example.com --dry-run
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `BOASE_TREASURY_PRIVATE_KEY` | Yes | BSV private key (WIF format) |
+| `NEXT_PUBLIC_SUPABASE_URL` | Optional | Supabase URL for version chain DB |
+| `SUPABASE_SERVICE_ROLE_KEY` | Optional | Supabase service role key |
+
+## Lineage
+
+`bitgit` is the evolution of [`bgit`](https://www.npmjs.com/package/bgit-cli) (v2, 2026). Same DNA — commit/push to Bitcoin — but instead of wrapping git with a payment gate, `bit` adds Bitcoin alongside git.
+
+## Part of the PATH Protocol
+
+- [$401](https://path401.com) — Identity
+- [$402](https://path402.com) — Payment
+- [$403](https://path403.com) — Conditions
+- [DNS-DEX](https://dns-dex.com) — Domain tokenization
+- [b0ase.com](https://b0ase.com) — Venture studio
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "bitgit",
+  "version": "0.1.0",
+  "description": "git push for Bitcoin — inscribe content, register domains, manage tokens on BSV",
+  "type": "module",
+  "bin": {
+    "bit": "./src/cli.ts"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "bitcoin",
+    "bsv",
+    "bitcoinsv",
+    "git",
+    "blockchain",
+    "inscription",
+    "op-return",
+    "cli",
+    "dns-dex",
+    "path402"
+  ],
+  "author": "b0ase <richard@b0ase.com> (https://b0ase.com)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/b0ase/bitgit.git"
+  },
+  "homepage": "https://github.com/b0ase/bitgit#readme",
+  "bugs": {
+    "url": "https://github.com/b0ase/bitgit/issues"
+  },
+  "dependencies": {
+    "@bsv/sdk": "^1.1.23",
+    "@supabase/supabase-js": "^2.49.1",
+    "dotenv": "^16.4.7",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/bsv/broadcast.ts

@@ -0,0 +1,56 @@
+/**
+ * Transaction broadcast with multi-provider fallback
+ *
+ * Chain: WhatsOnChain → GorillaPool ARC → TAAL ARC
+ * Extracted from 8+ identical copies across b0ase.com.
+ */
+
+const WHATSONCHAIN_API = 'https://api.whatsonchain.com/v1/bsv/main';
+const GORILLAPOOL_ARC = 'https://arc.gorillapool.io/v1/tx';
+const TAAL_ARC = 'https://arc.taal.com/v1/tx';
+
+/**
+ * Broadcast a signed transaction to the BSV network.
+ * Tries WoC first, then GorillaPool ARC, then TAAL ARC.
+ * Always trims the returned TXID.
+ */
+export async function broadcast(rawTx: string): Promise<string> {
+  // 1. WhatsOnChain
+  const wocRes = await fetch(`${WHATSONCHAIN_API}/tx/raw`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ txhex: rawTx }),
+  });
+  if (wocRes.ok) {
+    return (await wocRes.text()).replace(/"/g, '').trim();
+  }
+  const wocErr = await wocRes.text();
+
+  // 2. GorillaPool ARC (binary)
+  const gpRes = await fetch(GORILLAPOOL_ARC, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: Buffer.from(rawTx, 'hex'),
+  });
+  if (gpRes.ok) {
+    const data = await gpRes.json();
+    return (data.txid || '').trim();
+  }
+  const gpErr = await gpRes.text();
+
+  // 3. TAAL ARC (binary)
+  const taalRes = await fetch(TAAL_ARC, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: Buffer.from(rawTx, 'hex'),
+  });
+  if (taalRes.ok) {
+    const data = await taalRes.json();
+    return (data.txid || '').trim();
+  }
+  const taalErr = await taalRes.text();
+
+  throw new Error(
+    `Broadcast failed on all providers:\n  WoC: ${wocErr}\n  GorillaPool: ${gpErr}\n  TAAL: ${taalErr}`,
+  );
+}

package/src/bsv/script.ts

@@ -0,0 +1,103 @@
+/**
+ * OP_RETURN script builders
+ *
+ * Two formats:
+ * 1. Simple: OP_FALSE OP_RETURN <protocol> <content-type> <payload>
+ * 2. Bitcoin Schema: B + MAP + AIP (Bitcom protocols)
+ *
+ * Extracted from lib/blog-inscription.ts.
+ */
+
+import { PrivateKey, Script } from '@bsv/sdk';
+
+// Bitcom protocol addresses
+const B_PROTOCOL = '19HxigV4QyBv3tHpQVcUEQyq1pzZVdoAut';
+const MAP_PROTOCOL = '1PuQa7K62MiKCtssSLKy1kh56WWU7MtUR5';
+const AIP_PROTOCOL = '15PciHG22SNLQJXMoSUaWVi7WSqc7hCfva';
+
+/**
+ * Simple OP_RETURN: protocol tag + content-type + payload
+ */
+export function buildOpReturn(
+  protocol: string,
+  contentType: string,
+  payload: string,
+): Script {
+  const script = new Script();
+  script.writeOpCode(0);   // OP_FALSE
+  script.writeOpCode(106); // OP_RETURN
+  script.writeBin(Buffer.from(protocol, 'utf8'));
+  script.writeBin(Buffer.from(contentType, 'utf8'));
+  script.writeBin(Buffer.from(payload, 'utf8'));
+  return script;
+}
+
+/**
+ * Bitcoin Schema OP_RETURN: B (content) + MAP (metadata) + AIP (signature)
+ *
+ * @param content     - raw content (markdown, JSON, etc.)
+ * @param contentType - MIME type (e.g. 'text/markdown', 'application/json')
+ * @param mapData     - key-value pairs for MAP protocol indexing
+ * @param signingKey  - optional PrivateKey for AIP authorship proof
+ */
+export function buildBitcoinSchema(
+  content: string,
+  contentType: string,
+  mapData: Record<string, string>,
+  signingKey?: PrivateKey,
+): Script {
+  const script = new Script();
+  const contentBytes = Buffer.from(content, 'utf8');
+
+  script.writeOpCode(0);   // OP_FALSE
+  script.writeOpCode(106); // OP_RETURN
+
+  // --- B Protocol: content ---
+  script.writeBin(Buffer.from(B_PROTOCOL, 'utf8'));
+  script.writeBin(contentBytes);
+  script.writeBin(Buffer.from(contentType, 'utf8'));
+  script.writeBin(Buffer.from('utf-8', 'utf8'));
+
+  // --- Pipe separator ---
+  script.writeBin(Buffer.from('|', 'utf8'));
+
+  // --- MAP Protocol: metadata ---
+  script.writeBin(Buffer.from(MAP_PROTOCOL, 'utf8'));
+  script.writeBin(Buffer.from('SET', 'utf8'));
+
+  // Collect buffers for AIP signing payload
+  const sigParts: Buffer[] = [
+    Buffer.from(B_PROTOCOL),
+    contentBytes,
+    Buffer.from(contentType),
+    Buffer.from('utf-8'),
+    Buffer.from('|'),
+    Buffer.from(MAP_PROTOCOL),
+    Buffer.from('SET'),
+  ];
+
+  for (const [key, value] of Object.entries(mapData)) {
+    script.writeBin(Buffer.from(key, 'utf8'));
+    script.writeBin(Buffer.from(value, 'utf8'));
+    sigParts.push(Buffer.from(key), Buffer.from(value));
+  }
+
+  // --- Pipe separator ---
+  script.writeBin(Buffer.from('|', 'utf8'));
+  sigParts.push(Buffer.from('|'));
+
+  // --- AIP Protocol: authorship proof ---
+  if (signingKey) {
+    const address = signingKey.toPublicKey().toAddress();
+    const signingPayload = Buffer.concat(sigParts);
+    const signature = signingKey.sign(Array.from(signingPayload));
+    const sigBase64 = signature.toDER('base64') as string;
+
+    script.writeBin(Buffer.from(AIP_PROTOCOL, 'utf8'));
+    script.writeBin(Buffer.from('BITCOIN_ECDSA', 'utf8'));
+    script.writeBin(Buffer.from(address, 'utf8'));
+    script.writeBin(Buffer.from(sigBase64, 'utf8'));
+  }
+
+  return script;
+}

package/src/bsv/tx.ts

@@ -0,0 +1,90 @@
+/**
+ * Transaction building for OP_RETURN inscriptions
+ *
+ * Handles the mock-source-tx pattern and the sourceTXID overwrite bug.
+ * Extracted from 12+ identical copies across b0ase.com.
+ */
+
+import { PrivateKey, Transaction, P2PKH, Script } from '@bsv/sdk';
+import type { UTXO } from './utxo.js';
+
+export interface InscriptionTxResult {
+  tx: Transaction;
+  txid: string;
+  fee: number;
+  changeSats: number;
+}
+
+/**
+ * Build a signed transaction with an OP_RETURN data output.
+ *
+ * @param privateKey  - signing key
+ * @param utxo        - input UTXO
+ * @param opReturnScript - pre-built OP_RETURN script (from script.ts)
+ * @param feeRate     - sats per byte (default 0.5)
+ * @param payloadSize - estimated payload size for fee calc (if 0, uses 500 byte estimate)
+ */
+export async function buildInscriptionTx(opts: {
+  privateKey: PrivateKey;
+  utxo: UTXO;
+  opReturnScript: Script;
+  feeRate?: number;
+  payloadSize?: number;
+}): Promise<InscriptionTxResult> {
+  const { privateKey, utxo, opReturnScript, feeRate = 0.5, payloadSize = 0 } = opts;
+  const address = privateKey.toPublicKey().toAddress();
+
+  const tx = new Transaction();
+
+  // Build mock source transaction for SIGHASH verification.
+  // We only need enough outputs to reach the UTXO's vout index.
+  const mockSourceTx = new Transaction();
+  for (let i = 0; i <= utxo.vout; i++) {
+    mockSourceTx.addOutput({
+      lockingScript: i === utxo.vout ? utxo.script : new Script(),
+      satoshis: i === utxo.vout ? utxo.satoshis : 1,
+    });
+  }
+
+  tx.addInput({
+    sourceTXID: utxo.txid,
+    sourceOutputIndex: utxo.vout,
+    unlockingScriptTemplate: new P2PKH().unlock(privateKey),
+    sourceTransaction: mockSourceTx,
+  });
+
+  // CRITICAL: addInput() overwrites sourceTXID when sourceTransaction is provided.
+  // Must re-set it after addInput().
+  tx.inputs[0].sourceTXID = utxo.txid;
+
+  // OP_RETURN output (0 satoshis)
+  tx.addOutput({
+    lockingScript: opReturnScript,
+    satoshis: 0,
+  });
+
+  // Fee calculation
+  const estimatedSize = (payloadSize || 500) + 200; // payload + tx overhead
+  const fee = Math.max(500, Math.ceil(estimatedSize * feeRate));
+  const changeSats = utxo.satoshis - fee;
+
+  if (changeSats < 0) {
+    throw new Error(
+      `Insufficient sats for fee. Need ${fee}, have ${utxo.satoshis}`,
+    );
+  }
+
+  // Change output
+  if (changeSats > 0) {
+    tx.addOutput({
+      lockingScript: new P2PKH().lock(address),
+      satoshis: changeSats,
+    });
+  }
+
+  await tx.sign();
+
+  const txid = tx.id('hex') as string;
+
+  return { tx, txid, fee, changeSats };
+}

package/src/bsv/utxo.ts

@@ -0,0 +1,90 @@
+/**
+ * UTXO fetching from WhatsOnChain
+ *
+ * Extracted from 10+ identical copies across b0ase.com scripts.
+ */
+
+import { Script, P2PKH } from '@bsv/sdk';
+
+const WHATSONCHAIN_API = 'https://api.whatsonchain.com/v1/bsv/main';
+const FETCH_TIMEOUT_MS = 30_000;
+
+export interface UTXO {
+  txid: string;
+  vout: number;
+  satoshis: number;
+  script: Script;
+}
+
+/** Raw shape returned by WhatsOnChain API */
+interface WocUtxo {
+  tx_hash: string;
+  tx_pos: number;
+  value: number;
+}
+
+async function fetchWithTimeout(
+  url: string,
+  options: RequestInit = {},
+  timeoutMs = FETCH_TIMEOUT_MS,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === 'AbortError') {
+      throw new Error(`Request timeout after ${timeoutMs}ms`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Fetch all UTXOs for an address, sorted largest-first.
+ */
+export async function fetchUtxos(address: string): Promise<UTXO[]> {
+  const url = `${WHATSONCHAIN_API}/address/${address}/unspent`;
+  const response = await fetchWithTimeout(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch UTXOs: ${response.statusText}`);
+  }
+
+  const raw: WocUtxo[] = await response.json();
+  const lockScript = new P2PKH().lock(address);
+
+  return raw
+    .sort((a, b) => b.value - a.value)
+    .map((u) => ({
+      txid: u.tx_hash,
+      vout: u.tx_pos,
+      satoshis: u.value,
+      script: lockScript,
+    }));
+}
+
+/**
+ * Select a single UTXO with at least `minSats` satoshis.
+ * Optionally exclude specific txids (e.g. unconfirmed change).
+ */
+export async function selectUtxo(
+  address: string,
+  minSats = 1000,
+  excludeTxids: string[] = [],
+): Promise<UTXO> {
+  const utxos = await fetchUtxos(address);
+  const eligible = utxos.filter(
+    (u) => u.satoshis >= minSats && !excludeTxids.includes(u.txid),
+  );
+
+  if (eligible.length === 0) {
+    throw new Error(
+      `No UTXO with >= ${minSats} sats. Found ${utxos.length} total UTXOs.`,
+    );
+  }
+
+  return eligible[0]; // largest first
+}

package/src/cli.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env npx tsx
+/**
+ * bit — Bitcoin CLI for the PATH Protocol
+ *
+ * Usage:
+ *   bit init              Scaffold .bit.yaml for a new project
+ *   bit push              git push + inscribe changed content on BSV
+ *   bit register <domain> Inscribe a domain on DNS-DEX
+ *   bit status            Show Bitcoin state for this project
+ */
+
+import * as dotenv from 'dotenv';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+// Load .env.local from cwd, then .env
+const cwd = process.cwd();
+for (const envFile of ['.env.local', '.env']) {
+  const p = resolve(cwd, envFile);
+  if (existsSync(p)) {
+    dotenv.config({ path: p });
+    break;
+  }
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'init': {
+      const { init } = await import('./commands/init.js');
+      await init();
+      break;
+    }
+    case 'push': {
+      const { push } = await import('./commands/push.js');
+      await push(args.slice(1));
+      break;
+    }
+    case 'register': {
+      const domain = args[1];
+      if (!domain) {
+        console.error('Usage: bit register <domain>');
+        process.exit(1);
+      }
+      const { register } = await import('./commands/register.js');
+      await register(domain, args.slice(2));
+      break;
+    }
+    case 'status': {
+      const { status } = await import('./commands/status.js');
+      await status();
+      break;
+    }
+    case '--help':
+    case '-h':
+    case undefined: {
+      console.log(`
+bit — Bitcoin CLI for the PATH Protocol
+
+Commands:
+  bit init                Scaffold .bit.yaml for a new project
+  bit push                git push + inscribe changed content on BSV
+  bit register <domain>   Inscribe a domain on DNS-DEX
+  bit status              Show Bitcoin state for this project
+
+Options:
+  --help, -h   Show this help
+  --version    Show version
+
+Examples:
+  bit init
+  bit push
+  bit push --dry-run
+  bit register kwegwong.com
+  bit status
+`.trim());
+      break;
+    }
+    case '--version': {
+      const { readFileSync } = await import('fs');
+      const { resolve } = await import('path');
+      const { fileURLToPath } = await import('url');
+      const __dirname = resolve(fileURLToPath(import.meta.url), '..');
+      const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'));
+      console.log(pkg.version);
+      break;
+    }
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.error('Run `bit --help` for usage.');
+      process.exit(1);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal:', err.message || err);
+  process.exit(1);
+});