The chain secured by useful work.

Pearlscriptions

Ordinals-style inscriptions and the PRL-20 token standard on Pearl, with an independent read-only indexer.

Site ↗ Indexer ↗

PearlKeeper

Self-custodial PRL wallet for iOS, Android, macOS, Windows & Linux. BIP86 Taproot; keys never leave your device.

Site ↗

Lord of Pearls

Community block explorer with live node data, miners, holders and a peer map.

Explorer ↗

necklace-wallet

Open-source non-custodial Chrome (MV3) wallet with local Schnorr/Taproot signing.

GitHub ↗

Pearl Explorer

Community block explorer built by this repo — point it at your own pearld JSON-RPC and browse the chain. Zero dependencies.

Open explorer →

Testnet Faucet

Free tPRL for developers — bech32m address validation in the browser, payouts from your own Oyster wallet via the reference Node backend. Zero frontend dependencies.

Open faucet →

PRL-20 Explorer

Pearlscriptions & PRL-20 token dashboard — point it at a public Pearlscriptions indexer API and browse tokens, inscriptions, operations, and address balances. Zero dependencies.

Open PRL-20 explorer →

PRL-20 Token Launcher

Design a token, validate it against the exact on-chain PRL-20 rules, then inscribe deploy and mint operations with a real Taproot commit → reveal flow — built and signed entirely in your browser. Zero dependencies.

Open token launcher →

Pearl Pay

Accept PRL on any website — payment buttons, shareable invoices with QR and live Blockbook verification, a fresh BIP-86 Taproot address per invoice, and an installable WooCommerce gateway plugin. No custody, no server.

Open Pearl Pay →

Pearl Bazaar — PRL-20 Market

The PRL-20 marketplace — trade inscription transfer lots with atomic swaps. Sellers presign with SIGHASH_SINGLE | ANYONECANPAY; buyers verify and fill in one transaction. No escrow, no custody.

Open Pearl Bazaar →

Pearl Pulse — Portfolio Dashboard

The watch-only PRL portfolio tracker — live balances and tx history for every address you watch, real chain status from the public blockbook, and the live PRL/USDT price. No keys, no signatures, nothing broadcast.

Open Pearl Pulse →

Pearl Prove — Proof Desk

The cryptographic proof desk — verify merkle inclusion proofs for Pearl transactions against block headers, build merkle roots from txid lists, and decode 80-byte block headers with a real proof-of-work target check. Construction verified against upstream and a real mainnet block.

Open Pearl Prove →

Pearl Etch — Inscription Composer

Engrave PRL-20 inscriptions into Pearl — compose deploy, mint and transfer operations with strict spec validation, then build and sign the Taproot commit/reveal transaction pair locally. Batch mints share one reveal; the PRLS launch fee is added automatically. Witnesses self-verify like an indexer would parse them.

Open Pearl Etch →

Pearl Gallery — Inscription Wall

The gallery wall for Pearlscriptions — every on-chain inscription hung in brass frames: latest-inscriptions wall with lazy previews, content-type filters, lookup by number or id, address collections, and a detail view with full metadata. Reads any public Pearlscriptions indexer API; HTML and SVG are never executed.

Open Pearl Gallery →

Pearl Gift — Paper Wallets & Gift Cards

Give Pearl, beautifully — printable gift cards backed by real BIP-86 paper wallets (dedicated gift account, so keys never collide with your main wallet). Three card designs with the private key hidden behind the fold, plus a one-click redeem that sweeps every grain to your address in a locally-signed transaction. Keys never leave the page.

Open Pearl Gift →

Pearl Covenant — m-of-n Multisig Vaults

Forge m-of-n Taproot multisig vaults for PRL — up to 16 cosigners behind one CHECKSIGADD tapscript, sealed under a NUMS internal key so there is no keypath backdoor. Coordinate cosigner signing rounds as tamper-evident JSON: verify the round, sign locally, import cosigner signatures with per-signature verification, and finalize at quorum. Keys never leave the page.

Open Pearl Covenant →

Pearl Vesting — Timelocked PRL Vesting Schedules

Non-custodial vesting on Taproot — lock PRL for a beneficiary in linear or custom-dated tranches, one Taproot address per tranche with an absolute OP_CHECKLOCKTIMEVERIFY claim leaf (plus an optional funder clawback leaf, only after maturity). NUMS internal key, so no keypath backdoor. Forge the schedule, track funding over Blockbook, and claim or claw back one locally-signed transaction per matured tranche. Keys never leave the page.

Open Pearl Vesting →

Pearl Stream — Continuous PRL Payment Streaming

Payroll-style PRL streaming on Taproot — a funder streams PRL to a beneficiary at a fixed rate, one P2TR address per tick unlocking at start + i × interval. Live accrual dashboard (streamed / claimable / remaining), ONE multi-input batch-claim transaction sweeping all matured ticks, and funder cancel clawing back unmatured ticks in a single tx. NUMS internal key, tamper-evident descriptors, local signing with per-signature re-verification. Keys never leave the page.

Open Pearl Stream →

Pearl Bond — Fixed-Income Desk

Issue fully-collateralized fixed-income bonds on Taproot — every coupon and the principal is a pre-funded P2TR tranche output with an absolute OP_CHECKLOCKTIMEVERIFY claim leaf and a holder-reassignable transfer leaf, sealed under a NUMS internal key so there is no keypath backdoor. Forge the term sheet (30/360 coupon schedule, funding plan), redeem tranches with locally-signed + re-verified claims, and sell on the secondary market through atomic 0x83 (SINGLE|ANYONECANPAY) presigned transfers. YTM solver, accrued interest, tamper-evident descriptors. Keys never leave the page.

Open Pearl Bond →

Pearl Circle — Rotating Savings Club (ROSCA) Desk

N members contribute C PRL per round for N rounds — each round exactly one member takes the whole pot, and the payout order is drawn by a commit-reveal lottery nobody can rig. Every round's pot sits in a 2-leaf Taproot escrow (winner-claim leaf + m-of-n CLTV timeout-refund leaf) under a NUMS internal key. Found → Lottery → Fund → Claim & Refund → Track, with tamper-evident descriptors, per-round Blockbook lifecycle classification, local Schnorr signing with per-signature re-verification, double-confirm, and key wipe. Keys never leave the page.

Open Pearl Circle →

Pearl Bounty — Bug-Bounty / Task-Bounty Desk

Post bounties, hunt them, get paid on Taproot — no middleman. A bounty is a 2-leaf Taproot contract under a NUMS internal key: the poster's signature on the award leaf is the award decision, and a CLTV reclaim leaf (byte-identical to the audited escrow refund script) sweeps funds back after the deadline. Post → Fund → Hunt → Award → Reclaim → Verify, with commit-reveal hunter submissions, tamper-evident descriptors, local Schnorr signing with per-signature re-verification, double-confirm, and key wipe. Keys never leave the page.

Open Pearl Bounty →

Pearl Charity — Transparent Donation Desk

Run transparent donation campaigns on Pearl — donations go straight to the charity's own Taproot address; this page never holds, moves, or broadcasts funds. Forge a campaign (tamper-evident descriptor with 64-bit fingerprint, optional organizer signature with key wipe), track funding against the goal with live Blockbook stats and lifecycle classification, issue hash-bound donation receipts with CSV/JSON export, and independently verify any descriptor or receipt cross-checked against the chain. Launch → Fund → Receipts → Track → Verify. Keys never leave the page.

Open Pearl Charity →

Pearl Node — pearld Operator Console

Mission control for your own pearld node — chain status, sortable peer table, mempool depth, and mining telemetry over JSON-RPC. Strictly read-only: it only ever calls the six read-only RPC methods (getinfo, getmininginfo, getmempoolinfo, getpeerinfo, getnettotals, getchaintips), never sends state-changing calls, and never touches wallets. Ships with a zero-dependency relay.mjs (browsers can't call pearld directly — no CORS, self-signed TLS), health heuristics with honest warn/error lamps, and a loud network-mismatch guard. Overview → Peers → Mempool → Mining → Settings.

Open Pearl Node →

Pearl Metrics — pearld Prometheus Dashboard

Browser-local dashboard for pearld's Prometheus metrics endpoint from upstream PR #310 (opt-in --metricslisten, default port 9105 — labelled honestly as not yet in a released pearld). Paste or fetch a /metrics scrape and read chain-tip freshness, peer health with ban/rejection reasons, wire traffic per P2P command, per-method RPC latency computed from the real histogram buckets (exact mean, bucket-interpolated p95), mempool pressure against its configured limit, and per-second counter rates between scrapes. Health notes are heuristics and say so; a clearly-labelled sample scrape in the exact PR format is built in.

Open Pearl Metrics →

Pearl Treasury — DAO / Team Treasury Command Center

Command center for a team or DAO holding PRL in m-of-n Taproot vaults (emerald + gold vault-ledger theme): Vaults → Proposals → Sign → Disburse → Audit. Register covenant-style `covenant:v1:` vault descriptors and track confirmed balances with GET-only Blockbook reads, draft spend proposals (SHA-256 ids, 64-bit fingerprints, grain-exact integer amounts, P2TR payee validation), collect local BIP-340 cosigner signatures to quorum with per-signature re-verification and loud wrong-key refusal, then finalize real script-path Taproot spends with exact vBytes fee planning, intent-match checks, and dust refusal — plus a hash-chained audit log with one-click tamper check and CSV/JSON export. No new cryptography — audited Sign, Covenant, and Escrow cores throughout; keys in memory only with byte-zeroing wipe. Honest limits up front: no smart contracts on Pearl, so coordination is off-chain until broadcast; schedules are a calendar table; the page moves real PRL only when you broadcast the hex yourself.

Open Pearl Treasury →

Pearl Names — Human-readable names for Pearl addresses

Give your Taproot address a name — bind a memorable name.prl to your prl1… address by signing a canonical registration record with the BIP-86 key that controls it, then seal it on-chain in a prl-name Taproot inscription envelope: Register → Directory → Verify → Export. Name rules (3–63 chars, reserved list), wrong-key refusal on signing, standalone VALID/INVALID verifier that re-derives the address from the key and re-checks the BIP-340 signature, first-seen conflict resolution in the local directory, full commit→reveal planning with grain-exact fees, and witness self-verification before broadcast. No new cryptography — audited Sign/Etch cores throughout; keys in memory only.

Open Pearl Names →

Pearl Commons — quadratic funding rounds for PRL

Fund the commons the fair way. Open a round with a fixed PRL matching pool and a contribution window, register projects with chain-validated Taproot addresses, log contributions (or paste a txid and let the desk read the payment off Blockbook, GET-only), and the desk computes each project's quadratic match — (Σ√c_i)² − Σc_i, aggregated per donor, capital-constrained to the pool with the scale factor shown honestly: Rounds → Projects → Contribute → Results → Audit → Settings. Finalizing a round seals the results hash in a tamper-evident log; JSON/CSV export for everything. No escrow, no keys, no smart contracts — the pool is a pledged figure and payout stays manual; donor labels are self-declared, so results are best-effort, not sybil-proof. No new cryptography — the audited Sign core only.

Open Pearl Commons →

Pearl Fees — the fee-rate desk for PRL

Stop guessing what a Pearl transaction costs. Point the desk at your pearld RPC and it reads the live mempool, ranks every transaction in grains per vbyte, and gives you four honest bands — next block, ~10 minutes, ~1 hour, economy — each with a rough confirmation ETA from a real packing model (~1 MB blocks, 3m14s target). The size estimator plans P2TR key-spend transactions to the vbyte, and the bump planner fetches a stuck txid, measures its exact vsize from the raw bytes, and tells you what an RBF replacement or CPFP child must pay — including whether the original even signaled RBF. Read-only throughout: no signing, no broadcasting, no keys anywhere near the page; sample-data mode is always loudly labeled when no node is connected.

Open Pearl Fees →

Pearl ID — Sign-in with Pearl

Your key is your account — Pearl has no usernames, passwords, or OAuth. A site shows you a domain + challenge; you sign it with the BIP-340 Schnorr key that also controls your prl1… address and hand back an expiring credential anyone can verify: Keys → Sign in → Verify → Integrate. The verifier recomputes the address from the key (the username really is the key), checks the domain binding and expiry, and rules VALID / INVALID. No new cryptography — the audited Sign core throughout. Honest limits up front: a signature proves key control, not identity; credentials replay until expiry, so relying parties use single-use challenges and minute-scale lifetimes.

Open Pearl ID →

Pearl Oracle — Signed Price-Feed Ticker Desk

The signal beacon — mint a BIP-86 oracle key and publish BIP-340-signed price attestations (integer minor units + decimals, never floats) in a local hash chain: Identity → Publish → Feed → Verify. Each tick's id is SHA-256 of its canonical bytes, signed with the tweaked keypath key that also controls the oracle's prl1… address; the feed carries per-row VALID badges, a per-asset price chart, CSV/JSON export, a whole-chain tamper check, and a standalone verifier that rules VALID / INVALID with per-check rows. No new cryptography — the audited Sign core throughout. Honest limits up front: a signature proves authorship, not truth; the feed is local-only; the page never moves PRL.

Open Pearl Oracle →

Pearl Rain — Batch-Send PRL Airdrops

Make it rain — one funder key, one transaction, up to 250 recipients. Paste a recipient list (or import CSV), validate every Taproot address and dust rule, plan the exact fee with change back to the funder, then sign locally with per-signature re-verification before the hex is shown. Blockbook UTXO lookup or fully air-gapped paste mode. Keys never leave the page.

Open Pearl Rain →

Pearl Raffle — Provably-Fair PRL Raffles

The lottery vault — commit to a prize, a future settlement block, and weighted entries in a tamper-evident descriptor you must publish before the settlement block. Draw winners from the settlement block hash with a hand-verifiable SHA-256 derivation (1–3 prize rounds), verify anyone's draw standalone with a loud refusal on tampered entries, and export an exact payout plan as CSV plus pearl: payment QRs. Honest scope: the page never moves PRL — prize custody stays with the organizer.

Open Pearl Raffle →

Pearl Swap — Trustless PRL ⇄ BTC Atomic Swaps

The collision chamber — coordinate trustless PRL↔BTC atomic swaps over Taproot HTLCs. Alice locks PRL behind a hashlock/timelock script tree, Bob mirrors it with a byte-identical claim leaf on Bitcoin, Bob claims the PRL by revealing the preimage on-chain, and Alice reads it from his claim witness to take the BTC. Five steps: propose → lock → track → claim → refund, with T1>T2 timelock guards, local signing, and per-signature re-verification. Keys never leave the page.

Open Pearl Swap →

Pearl Auction — Sealed-Bid PRL Auction Hall

The auction hall — run sealed-bid PRL auctions without smart contracts, on a commit-reveal fairness protocol. List an item in a tamper-evident auction:v1: descriptor with minimum bid and block-height deadlines, take sealed SHA-256 bid commitments before the commit deadline, reveal bids (mismatch = loud refusal), and settle to the highest verified bid with ties broken by earliest reveal. Full derivation table, winner-pays-seller payment plan with pearl: QR, signed result record, and a standalone verifier. The page never moves PRL.

Open Pearl Auction →

Pearl Legacy — PRL Inheritance Vault

The dead-man's switch — a two-leaf Taproot vault where the owner can always spend via a heartbeat leaf, and the heir can claim only after n blocks of inactivity via a CSV-timelocked leaf, all under a NUMS internal key with no keypath backdoor. Plan a vault from a mnemonic/WIF/hex key or watch-only, fund it, watch it with GET-only Blockbook scans that re-verify every UTXO's script on-chain, build the heir's single-UTXO claim or the owner's multi-input heartbeat refresh (same address, fresh UTXO, exact fee math, every signature re-verified), and verify anyone's descriptor standalone against its claimed address. Keys never leave the page; broadcast needs two explicit confirmations.

Open Pearl Legacy →

Pearl Vanity — Forge Your Own prl1p… Address

The vanity forge — grind a custom Pearl Taproot address in your browser: pick a 1–5 character bech32 prefix, run up to 8 Web Worker threads with live rate/luck/ETA stats, and claim a real keypair whose address opens with prl1p + your prefix. Fresh random keys or BIP-86 grinding inside your own seed, every find re-derived from the secret before display, WIF export, and a live Schnorr proof the key controls the address. Keys never leave the page.

Open Pearl Vanity →

Pearl Recover — PRL Seed Recovery Scanner

The rescue beacon — paste a BIP-39 seed and scan every BIP-86 Taproot address it can generate (m/86'/{coin}'/{account}'/{change}/{index}, mainnet prl1… and testnet tprl1…) with GET-only Blockbook reads, standard 20-address gap limit, exact grain math, and CSV export. Discovery only: the page never signs, never broadcasts, and the lock button wipes the seed from memory; sweep found funds in Pearl Sign.

Open Pearl Recover →

Pearl Tipjar — PRL Donation Widget Generator

The tip-jar forge — configure a PRL donation widget (recipient address, 1–4 amount presets, optional goal, three original themes), preview it live, and copy one self-contained snippet onto your own site. The widget polls Blockbook GET-only and renders an animated glass jar filling with glowing grains, confetti on new tips, a tip feed, goal progress, and pearl: QR for the active preset — plus tamper-evident tipjar:v1: descriptors and a listen mode with CSV export. Read-only: it never moves funds.

Open Pearl Tipjar →

Pearl Sweep — UTXO Consolidation Optimizer

The tidal refinery — analyze a Pearl Taproot address's UTXO health (dust / uneconomic / healthy, value-distribution histogram, consolidation-savings estimate), plan a consolidation with grain-exact fee math and a breakeven guard that loudly refuses value-destroying sweeps, sign locally with per-signature Schnorr re-verification, track the consolidation txid, and prove the sweep with a post-consolidation re-scan. Keys never leave the page.

Open Pearl Sweep →

Pearl Vault — m-of-n Taproot Multisig Safe

The strongroom — forge a 1-of-1 to 5-of-5 Taproot multisig vault on a single CHECKSIGADD script leaf under a NUMS internal key (no keypath backdoor, ever), fund it over GET-only Blockbook reads, plan spends with exact script-path fee math, coordinate unsigned bundles and partial Schnorr signatures across cosigners with verify-on-add and per-signature re-verification, broadcast with two explicit clicks, and prove any descriptor with the standalone verifier. Keys never leave the page; a bad signature never reaches the chain.

Open Pearl Vault →

Pearl Channels — Off-Chain PRL Payment Channels

The switchboard desk — open a 2-of-2 Taproot payment channel with one counterparty (no smart contracts, pure script), fund it, and exchange signed commitment transactions off-chain: every payment is a new state, old states are revoked with revocation secrets, and you close cooperatively (immediate) or unilaterally (CSV-delayed claim). Six steps (Open → Fund → State → Close → Track → Verify) with a standalone PROVEN/NOT PROVEN verifier. Keys never leave the page; every signature is re-verified before assembly.

Open Pearl Channels →

Pearl Fund — Refundable Crowdfunding

The harbor launch — launch refundable PRL crowdfunding campaigns on pure Taproot script: creators set recipient, goal and deadline; each backer gets a personal pledge address (release needs recipient + creator co-sign, refunds need only the backer after the deadline). Five steps (Launch → Pledge → Track → Release → Refund) with a two-party signing-round coordinator, tamper-evident descriptors with loud-refusal verification, GET-only Blockbook tracking, and local Schnorr signing with per-signature re-verification. Keys never leave the page.

Open Pearl Fund →

Pearl Ballot — Off-Chain DAO Governance

The civic hall — run DAO votes without smart contracts on a signed-ballot protocol: draft proposals in tamper-evident pearl-ballot:v1: descriptors with block-height windows and snapshot heights, vote with locally-signed BIP-340 Schnorr ballots bound to your prl1/tprl1 address (keys never leave the page), tally with full signature re-verification, loud duplicate/wrong-key/tamper refusal and a hash-bound result record, plus a standalone verifier. Results are social consensus — the page never moves PRL.

Open Pearl Ballot →

Pearl Registry — Decentralized Handles

The embossed register — claim a human-readable handle on Pearl with a Taproot prl-name inscription: a directory tab resolving owners by first-seen consensus (lowest inscription number wins, transfers only from the current owner, releases free the handle), a 3-step claim wizard (handle + squatting guard, bech32m owner address, commit/reveal with exact grain fee math, dust refusal, double-confirm broadcast), and a verifier that re-scans the handle live and refuses tampered or losing records loudly with field-level reasons. No new cryptography — audited Sign core + Etch commit/reveal machinery; prl-name is an app-level convention, not Pearl consensus.

Open Pearl Registry →

Pearl Invoice — PRL Invoicing Studio

The ledger book — compose grain-exact PRL invoices and seal them into tamper-evident pearl-invoice:v1: descriptors (SHA-256 over canonical JSON), share a pearl: payment QR for the exact total, watch for payment with GET-only Blockbook reads (unpaid / partial with exact grains remaining / paid / overpaid, plus an air-gapped paste-txid path), and issue hash-bound receipts with CSV/JSON export — plus a standalone verifier that rules PROVEN or NOT PROVEN. Receive-only: the page never spends, never needs keys; optional fresh per-invoice BIP-86 receiving addresses with a memory wipe.

Open Pearl Invoice →

Pearl Tax — PRL Capital-Gains Desk

The midnight auditor — read-only PRL tax bookkeeping: watch prl1/tprl1 addresses, import history with GET-only Blockbook reads (or paste JSON air-gapped), classify every movement, supply your own PRL/USD prices, and get a grain-exact FIFO capital-gains report with a 365-day short/long split, fee-basis accounting, and CSV/JSON export. The report refuses to run while anything is unclassified or unpriced — nothing is ever guessed. Not tax advice.

Open Pearl Tax →

Pearl Watch — PRL Watchtower & Alert Desk

The lighthouse — watch up to 250 prl1/tprl1 addresses over GET-only Blockbook reads (never asks for keys, seeds, or passwords). Animated lighthouse beam with a lantern signal, edge-triggered alert rules (incoming/outgoing ≥ amount, balance crossings, txid confirmation targets), an event journal with CSV/JSON export, browser notifications + sound, and a standalone confirmation tracker for any txid. The first sweep treats history as history — only new sightings fire alerts.

Open Pearl Watch →

Pearl Batch — PRL Batch Payments Studio

The freight terminal — dispatch one Pearl transaction to up to 250 recipients: a 5-step wizard (Recipients → Fund → Review → Sign → Broadcast) with bech32m-validated manifests, dust refusal, duplicate merging (or loud refusal), GET-only Blockbook UTXO reads plus an air-gapped paste path, grain-exact fee/change math via the audited keypathTxVBytes sizer, unsigned JSON bundles with 64-bit fingerprints for cold signing, address-match key guard, per-input Schnorr re-verification, double-confirm broadcast, and a standalone txid verifier. No new cryptography — audited Sign core throughout.

Open Pearl Batch →

Pearl Payroll — PRL Payroll Desk

The paymaster's office — run PRL payroll through a 6-step wizard (Roster → Schedule → Fund → Review → Sign → Broadcast): a bech32m-validated roster with dust refusal, duplicate merging (or loud refusal) and add/edit/remove rows, a schedule planner with the next 12 pay dates plus a payday countdown (a planner, never auto-pay — Pearl has no smart contracts), GET-only Blockbook UTXO reads plus an air-gapped paste path with a fewer-than-2-runs warning, grain-exact review with a double-confirm gate, unsigned JSON bundles with 64-bit fingerprints for cold signing, an address-match key guard, per-input Schnorr re-verification, key wipe, and a History ledger with per-payee lifetime totals. No new cryptography — audited Sign core throughout.

Open Pearl Payroll →

Pearl Games — Provably-Fair Taproot Games

The midnight casino — commit-reveal coin flip and dice games on pure Pearl Taproot, no smart contracts. Dealer commits to sha256(secret) before the round ID is drawn, both sides fund their own Taproot escrow (shared 2-of-2 settle leaf + per-depositor CLTV refund leaf), the winner and loser co-sign the pot to the winner, and anyone can re-derive the outcome from the public transcript. Solo practice mode included. Keys never leave the page.

Open Pearl Games →

Pearl Notary — Proof of Existence

Seal any document's SHA-256 fingerprint into Pearl with a Taproot inscription — the chain is the witness. Five-step wizard (document → key → commit → reveal → seal) with a printable certificate, plus a standalone verifier that re-hashes and checks the on-chain envelope. Documents never leave your machine.

Open Pearl Notary →

Pearl Escrow — Bonded 2-of-3 Escrow

Trust-minimized escrow on Taproot — buyer, seller and arbiter lock funds behind a 2-of-3 tapscript with native OP_CHECKSIGADD, while the buyer keeps a timelocked CLTV refund path. Build the contract, fund it, collect two signatures locally with per-key verification, and broadcast — keys never leave the page.

Open Pearl Escrow →

Pearl Subscribe — Recurring PRL Standing Orders

The chronometer desk — recurring PRL payments with no smart contracts. Fund one transaction with one Taproot output per period, pre-sign each payment with block-height nLockTime + sequence 0xfffffffe, and the merchant broadcasts each when due. Cancel any unpaid period by double-spending its output. Seven steps: Service → Terms → Fund → Pre-sign → Track → Cancel → Verify. Honest design: the subscriber can always double-spend (a payment can fail), the merchant can lose the signed set, and dates are approximate — only the heights are enforced.

Open Pearl Subscribe →

Pearl Solvency — Proof-of-Reserves Desk

The audit room — custodians prove on-chain PRL reserves against declared liabilities. Sign a canonical challenge per address with BIP-340 Schnorr (address-match guarded, keys wiped after signing), publish a tamper-evident bundle with a 64-bit fingerprint, and let anyone re-verify: every signature re-checked, every funding script byte-compared, grains summed exactly. Five steps: Custodian → Addresses → Prove → Bundle → Verify. Honest scope: proves assets, never liabilities.

Open Pearl Solvency →

Pearl Atomic — Cross-Chain HTLC Desk

Trust-minimized cross-chain swaps on Pearl Taproot — lock PRL behind a hash-time-locked contract (SHA-256 secret preimage + CLTV timeout) with a NUMS internal key, so the counterparty claims with the secret before the timeout or you refund after it. Six-step wizard (Deal → Contract → Fund → Track → Settle → Verify) with tamper-evident descriptors, local Schnorr signing, air-gapped unsigned bundles, and a standalone verifier. Keys never leave the page.

Open Pearl Atomic →

Pearl Lend — Collateralized PRL Loans

The counting-house desk — overcollateralized peer-to-peer PRL loans on pure Taproot script (no smart contracts, no oracles): the borrower locks PRL collateral in a two-leaf vault under a NUMS internal key, repays early through a 2-of-2 repay leaf with lender co-signing and signature re-verification, or the lender sweeps via a CSV-delayed default leaf after term + grace. Six steps (Offer → Lock → Fund → Track → Repay → Close & Verify) with tamper-evident descriptors, grain-exact interest math, mutual-close agreements, double-confirm broadcast, and a standalone PROVEN/NOT PROVEN verifier. Keys never leave the page; honest about the pawn-shop model.

Open Pearl Lend →

Pearl Dividend — PRL-20 Holder Distribution Desk

The luminous transfer-agent / mint-hall desk — pay PRL-20 holders from a CSV snapshot: seal the holder set with a tamper-evident fingerprint, compute grain-exact shares (proportional, equal, or fixed per holder) with explicit dust and remainder accounting, fund each payout chunk, sign locally with BIP-340 Schnorr (air-gapped unsigned bundles, keys wiped after signing), and broadcast with double-confirm — plus a standalone PROVEN / NOT PROVEN verifier that recomputes every share and audits every payout transaction. Honest about indexer limits: the indexer supplies token metadata only, the holder set is yours.

Open Pearl Dividend →

Pearl Split — Group Expense Settlement Desk

The dark tavern-ledger desk — split group expenses in PRL with grain-exact shares (equal, weighted shares, or percentages with deterministic remainder distribution), compute the minimal who-pays-whom transfer set, and have each debtor sign their own payment locally with BIP-340 Schnorr (air-gapped unsigned bundles, keys wiped after signing, double-confirm broadcast) — plus a local ledger book of settled tabs with CSV export. Loud dust refusal; honest about what the desk can and cannot know.

Open Pearl Split →

Pearl Boost — Stuck-Transaction Accelerator Desk

The launchpad — light the fuse on a stuck PRL transaction: diagnose it with GET-only Blockbook reads (fee, vBytes, effective feerate, BIP-125 signal per pearld's own mempool policy), then accelerate with CPFP child-pays-for-parent or an RBF replacement — exact package-feerate math, local Schnorr signing with per-signature re-verification, double-confirm broadcast, and a standalone PROVEN / NOT PROVEN verifier. Keys never leave the page and are wiped after use. Honest about the one thing math can't buy: no confirmation is guaranteed.

Open Pearl Boost →

Pearl Quorum — n-of-m Multisig Shared-Custody Desk

The council chamber — shared custody for PRL on pure Taproot script: forge a 1-of-1 to 7-of-7 vault from cosigner public keys (m-of-n CHECKSIGADD leaf under a NUMS internal key, no keypath backdoor by default), fund it, plan grain-exact spends, and collect Schnorr signatures slot by slot — including remote cosigners via tamper-evident signature bundles that are re-verified before counting — then finalize at quorum and broadcast with double-confirm. Keys never leave the page and are wiped after every signing. Honest about the one thing code can't check: that your cosigners are really distinct people.

Open Pearl Quorum →

Pearl Sign — Transaction Forge

The air-gapped Taproot transaction workbench — derive BIP-86 keys offline, assemble UTXOs, build exact wire bytes, sign every input with BIP-341 keypath Schnorr, re-verify each signature locally, then broadcast. SIGHASH_SINGLE | ANYONECANPAY presigns for atomic swaps included.

Open Pearl Sign →

Pearl Rig — Profitability Planner

The GPU rig economics desk — wall-power fleet builder, live PRL/USD price, measured-output or TH/s-yield revenue models, pool fees, capex break-even and price sensitivity. Companion to the mining calculator's reward side.

Open Pearl Rig →

Mining Calculator

Estimate PRL mining rewards with the exact upstream emission formula — subsidy at any height, your share of network useful work, revenue vs. power cost, plus the full emission schedule chart. Zero dependencies.

Open calculator →

Pearl Wallet

The self-custody PRL vault — installable iOS/Android PWA, Taproot-native BIP-86 addresses, local Schnorr signing, encrypted AES-256-GCM backups, PRL-20 balances. Your keys never leave the device.

Open Pearl Wallet →

Pearl Predict — Prediction-Market Desk

The after-hours trading floor — prediction markets on pure Taproot with no smart contracts: each outcome gets a deterministic funding address under a 2-leaf taptree (arbiter award leaf + CLTV refund leaf, both byte-identical to audited lineage), traders fund their side, and after the trading deadline the arbiter signs one proportional-payout transaction — winners split the whole pot pro-rata, grain-exact. Five steps: Create → Fund → Resolve → Track → Verify, with tamper-evident descriptors and a standalone PROVEN / NOT PROVEN verifier. Keys never leave the page. Honest about the one thing scripts can't prove: the arbiter signs honest payouts.

Open Pearl Predict →

Pearl Paywall — Content Paywall Desk

The velvet-rope backstage — put your content behind PRL with no accounts, no Stripe, no server: seal a tamper-evident paywall descriptor, take the exact PRL price on-chain, and buyers mint a Schnorr-signed access token with the funding key, bound to that paywall and that payment only. Five steps: Create → Pay → Token → Verify → Snippet, with a standalone PROVEN / NOT PROVEN verifier and a dependency-free embed snippet for your own site. Funding keys live in memory only and are wiped on demand. Honest about the one thing scripts can't prove: snippet-level protection is strong for soft delivery, not DRM.

Open Pearl Paywall →

Pearl Monetary — Issuance & Halving Desk

The central bank of Pearl — the exact block-subsidy formula from upstream validate.go recomputed grain-for-grain in your browser (BigInt, pinned to the emission_test.go vectors): live era, block subsidy and next decay-milestone countdown from Blockbook with a labeled stale-snapshot fallback, SVG issuance curve with a you-are-here marker, era-by-era subsidy schedule, and height/date/grains/maturity explorer tools. Client-side only, honest about every estimate.

Open Pearl Monetary →

Pearl Drop — PRL-20 Airdrop Campaign Desk

The raindrop-storm desk for PRL-20 airdrops — define a campaign with a SHA-256 campaign id, paste a recipient CSV with strict bech32m address validation and first-seen-wins dedupe, hash the list into a sorted-pair Merkle tree, seal a tamper-evident drop descriptor (with a prl-drop inscription envelope ready for Pearl Etch), and let anyone verify their claim against the sealed root. Six tabs: Campaign → Recipients → Merkle → Seal → Claim → Method, with a standalone PROVEN / NOT PROVEN seal verifier. Pure client-side, honest limits always visible: the desk never holds funds, allocations are pledged amounts, distribution is manual.

Open Pearl Drop →

Pearl PSBT — Taproot PSBT Signing Workbench

The machine-shop desk for Taproot PSBTs — draft an unsigned PSBT from your UTXOs, inspect every input's witness UTXO, sighash and tap leaves before a key touches it, sign keypath or scriptpath with exact BIP-341 sighashes (re-verified before the PSBT is mutated), combine co-signer PSBTs, and finalize to broadcast-ready tx hex. Six tabs: Create → Inspect → Sign → Combine → Finalize → Method. No new cryptography: every primitive is vendored from the audited sign core, and the sighash construction is differentially pinned byte-equal against it. Pure client-side — the desk never broadcasts and keys live in memory for one signing call only.

Open Pearl PSBT →

Pearl Hedge — Taproot Options Desk

The storm-chart trading desk for PRL options — covered calls and protective puts in pure Taproot with no smart contracts: the writer locks collateral in a 2-leaf vault under a NUMS internal key (hashlocked exercise leaf for the buyer, CLTV refund leaf for the writer), the desk verifies the buyer's strike payment on Blockbook before the buyer's exercise tx is built, and both spends are locally signed with per-signature re-verification. Five steps: Write → Fund → Exercise → Track → Verify, with tamper-evident descriptors, a sealed commitment, and a standalone PROVEN / NOT PROVEN verifier. Honest about the one thing scripts can't prove: the strike leg is verified off-chain, never atomically on-chain.

Open Pearl Hedge →

Pearl Policy — Taproot Policy-Tree Studio

The blueprint studio for PRL authorization — design a Taproot script tree from audited templates only (KeyLock byte-identical to the Bounty award leaf, TimelockRefund byte-identical to the Escrow refund leaf, MultiSig from the Covenant pattern), under a NUMS, BIP-86, or pasted internal key. Five steps: Design → Address → Verify → Export → Learn: real P2TR address, spend-ready per-leaf control blocks with an SVG tree map, a standalone PROVEN / NOT PROVEN descriptor verifier, shareable #p= links, and an honest explainer of what policy trees prove versus what they don't. Fully offline — this page never moves PRL and never broadcasts.

Open Pearl Policy →

Pearl Mesh — MuSig2 Collaborative Keypath Desk

The weaver's loom for shared PRL custody — an n-of-n MuSig2 aggregate Schnorr key whose funds look exactly like a single-key Taproot payment (no scripts, nothing on-chain to mark it as shared). Five steps: Setup → Aggregate → Fund → Sign → Verify: sorted-key aggregation with rogue-key-proof coefficients and even-y normalization, a TapTweaked P2TR address, an interactive signing ceremony (nonce-commitment bundles → per-member local signing → aggregated partials, one BIP-340 signature), a sealed pearl-mesh:v1 descriptor, and standalone PROVEN / NOT PROVEN verifiers. The page never moves PRL and never broadcasts — keys stay on each member's own device.

Open Pearl Mesh →

Pearl Will — Taproot Inheritance Vaults

The testamentary vault for PRL — a 2-leaf Taproot desk under a NUMS internal key: the owner reclaims anytime via leaf O, and m-of-n heirs claim only at/after an unlock block via the CLTV-gated leaf H. Five steps: Draft → Fund → Watch → Claim → Verify: canonical heir-key sorting, sealed descriptors with a standalone PROVEN / NOT PROVEN verifier, live Blockbook funding/tip, exact vByte fee previews for both claim paths, and a claim builder that refuses before the unlock block and re-verifies every spend from its decoded hex. Not legal advice — the scripts enforce routing, not intent.

Open Pearl Will →

Pearl Burn — Provable-Burn Desk

The furnace for PRL — derive provably-unspendable Taproot burn addresses from a public tag (NUMS-style: no private key exists, by construction). Four steps: Generate → Plan → Certify → Verify: exact unsigned burn txs with real vByte fee math (154 vB / 111 vB), a 333-grain dust floor with loud refusals, tamper-evident pearl-burn:v1 certificates with a standalone PROVEN / NOT PROVEN verifier, and GET-only Blockbook confirmation of on-chain burns. This page never holds keys, never signs, never broadcasts — burns are irreversible.

Open Pearl Burn →

Pearl Pact — Discreet Log Contract Desk

The wax-seal desk for oracle-conditional PRL contracts — two parties lock collateral in a 2-of-2 Taproot funding output under a NUMS internal key, pre-sign one CET per outcome with Schnorr adaptor signatures encrypted to the oracle's announcement points, and execute trustlessly when the oracle attests. Five steps: Draft → Fund → Seal → Execute → Refund, with a timelocked refund leg as insurance, sealed tamper-evident descriptors, and standalone PROVEN / NOT PROVEN verification. The oracle can't steal — it can only pick the winner.

Open Pearl Pact →

Pearl Sighash Studio

The drafting table for Taproot signatures — build a spending scenario and watch the exact BIP-342 sighash digest being assembled byte by byte. Five steps: Build → Anatomy → Compare → Sign → Verify, with a full intermediate-hash walkthrough, a side-by-side diff of all seven sighash flags (why NONE omits sha_outputs, what ANYONECANPAY drops), BIP-340 Schnorr signing, tamper-evident pearl-sighash:v1 descriptors with a standalone PROVEN / NOT PROVEN verifier, and a live replay of the official BIP-341 wallet test vectors, byte-exact. Educational reference implementation — review the source before trusting it with real money.

Open Sighash Studio →

Pearl Hush — Silent Payments Desk

The midnight desk for BIP-352 silent payments — one static sp1… address, a whisper of unlinkable taproot outputs. Five steps: Setup → Send → Scan → Labels → Verify: generate scan/spend keys locally, derive exact sender outputs with prl1… addresses, replay the receiver scan to find and spend your payments (labeled ones too), mint quiet sub-addresses per label, and prove the page's own math byte-exact against the official BIP-352 vectors. Forward-looking standards reference — no wallet support yet; this page never signs, never broadcasts.

Open Pearl Hush →

Pearl Payjoin — BIP-78 Transaction Desk

The duet desk for two-party PRL transactions — the receiver publishes a payjoin offer, the sender funds and signs the original, the receiver answers with a proposal that adds their own input, and the sender runs the full 15-check BIP-78 verification before re-signing and finalizing. Exact integer-grain fee policy with bounded payment deductions, loud refusals on every protocol violation, and an in-page self-test that replays the whole dance with the public test vectors. One transaction, two wallets, no common-input-ownership heuristic.

Open Pearl Payjoin →

Pearl Atlas — BIP-380 Output-Descriptor Desk new

The cartographer's map-room for output descriptors — paste any descriptor and watch it get charted: grammar parse, BIP-380 checksum state, every key with origin, type, and range, and the full Taproot tree (internal key, Merkle root, output key, per-leaf control blocks). Add or verify checksums, derive addresses over an index range per BIP-386 (tr() and addr() are Pearl-spendable on the Taproot-only chain), chart five template shapes, and run a pinned self-test battery that replays the official BIP-380/BIP-393 vectors byte-exact. Fully offline — keys never leave the page.

Open Pearl Atlas →

Pearl Foundry — Mining Pool

The open-source PRL stratum pool — HeroMiners/LuckyPool/Kryptex dialects, real zk-pow share verification, vardiff, PPLNS payouts to the grain, and a live dashboard. Run it yourself.

Open pool dashboard →