Keys and addresses

Owning PRL doesn’t mean having an account somewhere. It means knowing a secret number.

This page follows that number as your wallet turns it into a public key, then into an address you can hand to anyone.

What is a private key?

Everything starts with a random number. Your wallet picks one between 1 and roughly $1.16 \times 10^{77}$ , a number up to 78 digits long. That number is your private key.

There are so many possible keys that guessing someone else’s is hopeless. The danger isn’t guessing; it’s a key that wasn’t really random, or one that leaks. So never invent your own key from a birthday or a favorite phrase. Let the wallet’s random number generator do it.

Whoever knows a private key can spend the coins it controls. That’s the whole security model, in one sentence.

What is a public key?

From the private key, your wallet computes a public key, using elliptic-curve math on a curve called secp256k1. It’s the same curve Bitcoin uses.

Think of mixing paint. Yellow and blue make green in seconds, but no one can take green paint and separate it back into yellow and blue. Going from private key to public key is quick and easy; going back is believed to be impossible with today’s computers.

That one-way street is what lets you show your public key to the world while your private key stays secret.

How does a key prove ownership?

With a signature. When you spend, your wallet combines your private key with the exact transaction and produces a 64-byte Schnorr signature.

Anyone can check it against your public key. Nobody can make one without the private key, and a signature for one transaction is useless for any other.

What is an address?

An address is what you give people so they can pay you. A Pearl address looks like this:

prl1pmfr3p9j00pfxjh0zmgp99y8zftmd3s5pmedqhyptwy6lm87hf5sse9xfq3

That one belongs to private key number 1, which is famous precisely because everyone knows it. Never send coins to it: anyone could spend them.

Every Pearl mainnet address is exactly 63 characters, and every one is built from the same five parts.

The parts of a Pearl Taproot address. The middle 52 characters are shortened here.

prl is the human-readable part. It names the network: prl for the real one, tprl for test networks.
1 is a separator, so software knows where the prefix ends.
p is the witness version. p means version 1, a Taproot address, which is what wallets make by default. A z here would mean version 2, a P2MR address.
The next 52 characters hold 32 bytes: on a Taproot address, that’s a public key itself, not a hash of one.
The last 6 characters are the checksum.

The key inside the address isn’t quite your public key. Your wallet first applies a small, standard adjustment called the Taproot tweak, which mixes in a hash of the key. That’s what lets an address quietly commit to backup spending rules, without showing them.

What does the checksum do?

The last six characters are calculated from everything before them, using a format called bech32m. Mistype a character, and the checksum almost certainly stops fitting. Your wallet refuses the address before any coins move.

The format also leaves out characters that are easy to confuse. After the separator, you’ll never see the letters b, i or o, or the digit 1.

Try it: change any character of the address below and watch it turn invalid.

Bech32m explorer

Every part of a prl1 address, and the checksum that catches typos

Address 63 characters

Valid Pearl mainnet address

Taproot (P2TR) · the checksum matches

Prefix (HRP): prl mainnet
Witness version: p = 1 Taproot (P2TR)
Checksum: e9xfq3 matches (bech32m)
Program: da4710964f7852695de2da025290e24af6d8c281de5a0b902b7135fd9fd74d21
Locking script: 51 20 da4710964f7852695de2da025290e24af6d8c281de5a0b902b7135fd9fd74d21

See the 5-bit → 8-bit regrouping

The 52 program letters carry 260 bits. Read them as bytes (8 bits each) and you get 32 bytes, with 4 zero bits of padding left over.

11011010010001110001000010010110010011110111100001010010011010010101110111100010110110100000001001010010100100001110001001001010111101101101100011000010100000011101111001011010000010111001000000101011011100010011010111111101100111111101011101001101001000010000

Show every step

Check the letter case
All lower case, as expected.
Split at the last '1'
Everything before the last '1' is the human-readable part; the 59 characters after it are the data part.
Read the prefix
"prl" means Pearl mainnet.
Turn each character into a 5-bit number
Each character is its position in the alphabet qpzry9x8gf2tvdw0s3jn54khce6mua7l (q=0 … l=31). The first is the witness version, the last 6 are the checksum.
Verify the checksum
Running the BCH polymod over the expanded prefix and all data gives the bech32m constant 0x2bc830a3, so the checksum is valid.
Read the witness version
"p" = 1: a Taproot (P2TR) address.
Regroup 5-bit numbers into bytes
52 characters × 5 bits = 260 bits; the last 4 padding bits are zero, leaving 256 bits = 32 bytes: the tweaked public key Q.
Build the locking script
OP_1 OP_PUSHBYTES_32 <program>: the scriptPubKey a transaction output uses to pay this address.

Runs in your browser · nothing is sent src/lib/bech32m.ts · BIP-350 + Pearl’s rules

Make a guess

You copy an address and accidentally change one character. What happens when you try to send?

Think of your answer first, then check it.

Answer Your wallet refuses to send.

The checksum was computed from the original characters. With one changed, it no longer matches, so the wallet knows the address is wrong. Your coins stay where they are, and you can paste the address again.

How does it all fit together?

Follow one key all the way through, step by step: random number, public key, tweak, address.

Key forge

Private key → public key → Taproot tweak → prl1 address

For learning only. A key shown on a web page is not secret. Never send real PRL to an address made here.

Private key as a number 1 – 1,000,000

Key 1 is the most famous key there is: its public key is the generator point G itself. Anyone can spend from its addresses.

1
Private key d

A secret number between 1 and n − 1 (n ≈ 1.16 × 10⁷⁷). 32 bytes.

0000000000000000000000000000000000000000000000000000000000000001
2
Public key P = d·G

Multiply the curve’s starting point G by d. Compressed: a parity byte, then x.

0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

02 · y is even Taproot keeps only x (32 bytes, “x-only”) and assumes the even y.
3
Tweak t

t = TaggedHash(“TapTweak”, P.x)

3cf5216d476a5e637bf0da674e50ddf55c403270dd36494dfcca438132fa30e7

BIP-86: no script tree, so the tweak commits to the key alone. It proves there is no hidden script.
4
Output key Q = P + t·G

The key that actually goes on the chain. Its private key is d + t (with d negated first if P’s y was odd).

da4710964f7852695de2da025290e24af6d8c281de5a0b902b7135fd9fd74d21
5
Address bech32m

Prefix + “1” + witness version 1 (“p”) + Q in 5-bit letters + a 6-letter checksum.

prl1pmfr3p9j00pfxjh0zmgp99y8zftmd3s5pmedqhyptwy6lm87hf5sse9xfq3

scriptPubKey 51 20 da 47 10 96… (63 characters)

Runs in your browser · nothing is sent · keys are never saved src/lib/keys.ts · bech32m.ts

Your address: yes. That’s what it’s for. For privacy, wallets usually give you a fresh one each time.
Your public key: a tweaked version of it is inside your address already.
Your private key: never, with anyone, for any reason. The same goes for the 12 words that back it up, which the next page explains.

One private key is fine for one address. But wallets juggle hundreds of keys, and nobody wants to back up hundreds of 78-digit numbers. That’s where the 12 words come in.