Build on the original Bitcoin
protocol — at scale.

from bitsv import PrivateKey
import requests

# 1. Load key (mainnet)
key = PrivateKey('your-wif-here')

# 2. Check balance
balance = key.get_balance('satoshi')
print(f"Balance: {balance} satoshis")

# 3. Send BSV — dead simple
outputs = [
    ('recipient-address', 10000, 'satoshi'),
]
txid = key.send(outputs)
print(f"Sent! txid: {txid}")

# 4. Write data on-chain (OP_RETURN)
data = b"Hello, BSV!"
txid = key.send_op_return([data])

import { PrivateKey, Transaction, P2PKH } from '@bsv/sdk'
import express from 'express'

const app = express()
const PRICE_SATOSHIS = 100  // ~$0.00003 per API call

// Middleware: verify BSV micropayment header
async function requirePayment(req, res, next) {
  const txid = req.headers['x-payment-txid']
  if (!txid) return res.status(402).json({
    error: 'Payment Required',
    address: MERCHANT_ADDRESS,
    amount: PRICE_SATOSHIS
  })

  const valid = await verifyPayment(txid, PRICE_SATOSHIS)
  if (!valid) return res.status(402).json({ error: 'Invalid payment' })
  next()
}

app.get('/api/data', requirePayment, (req, res) => {
  res.json({ data: "Paid content here" })
})

// A stateful counter contract on BSV
contract Counter {
    // State: persisted across contract calls
    @state
    int count;

    // Constructor: initialize counter
    constructor(int count) {
        this.count = count;
    }

    // Increment and propagate state
    @method
    public function increment(SigHashPreimage txPreimage, int amount) {
        this.count++;

        // Ensure state is propagated to next output
        bytes outputScript = this.getStateScript();
        bytes output = Utils.buildOutput(outputScript, amount);
        require(hash256(output) == SigHash.hashOutputs(txPreimage));
    }
}

// Deploy and call from JavaScript:
// const counter = new Counter(0)
// await counter.deploy(1000) // 1000 satoshis locked
// await counter.increment(preimage, 1000)