Types of Cryptocurrencies

Go: open a terminal in a folder you can write to, e.g. cd ~/Desktop (Windows: cd %USERPROFILE%\Desktop).

Do: save this as supply.py and run python3 supply.py. The whole rule is: 50 coins per block, halving every 210,000 blocks, forever.

reward = 50.0                 # coins per block at the start
BLOCKS_PER_ERA = 210_000      # the halving interval

total, era = 0.0, 0
while reward > 0.00000001:
    total += reward * BLOCKS_PER_ERA
    era += 1
    reward /= 2
    if era <= 4 or era == 33:
        print(f"after era {era:>2}: {total:>14,.0f} coins issued, next reward {reward:g}")

print(f"\ntotal ever issued: {total:,.0f}")

You should see: the famous number falling out of the rule:

after era  1:     10,500,000 coins issued, next reward 25
after era  2:     15,750,000 coins issued, next reward 12.5
after era  3:     18,375,000 coins issued, next reward 6.25
after era  4:     19,687,500 coins issued, next reward 3.125
after era 33:     21,000,000 coins issued, next reward 5.82077e-09

total ever issued: 21,000,000

Look at era 1: half of all the coins that will ever exist were issued in the first period. Nobody decreed “21 million” as a target — it is what a halving schedule adds up to, and it is enforced by every node refusing a block that pays itself more than the rule allows.

If not: if the loop never ends, the halving line is reward / 2 without the assignment — it must be reward /= 2. A total of 42,000,000 means the reward is doubling.

Go: same folder. Most coins are not capped, and that is a design choice rather than a flaw — but it has a consequence worth seeing.

Do: save this as inflation.py and run it. You hold a thousand coins in both worlds and never buy or sell.

capped, inflating = 21_000_000.0, 21_000_000.0
my_coins = 1_000.0

print(f"{'year':>4} {'capped supply':>15} {'your share':>11} | "
      f"{'inflating 5%/yr':>16} {'your share':>11}")
for year in range(0, 21, 5):
    print(f"{year:>4} {capped:>15,.0f} {my_coins / capped:>10.4%} | "
          f"{inflating:>16,.0f} {my_coins / inflating:>10.4%}")
    for _ in range(5):
        inflating *= 1.05

You should see: the same holding meaning steadily less:

year   capped supply  your share |  inflating 5%/yr  your share
   0      21,000,000    0.0048% |       21,000,000    0.0048%
   5      21,000,000    0.0048% |       26,801,913    0.0037%
  10      21,000,000    0.0048% |       34,206,787    0.0029%
  15      21,000,000    0.0048% |       43,657,492    0.0023%
  20      21,000,000    0.0048% |       55,719,252    0.0018%

After twenty years the balance is identical and the ownership share has fallen by more than half. That is the honest way to compare a capped coin with an inflationary one — and it is also why “staking rewards” paid in new coins are not straightforwardly income: if everyone stakes, everyone’s share stays where it started.

If not: if both columns stay identical, the inner loop is not running — the five multiplications must happen inside the year loop, after the print.

Go: same folder. A stablecoin is a promise to redeem one token for one dollar. The question is always what stands behind the promise.

Do: save this as peg.py and run it.

issued = 1_000_000.0            # stablecoins in circulation, each meant to be worth 1 dollar

for name, collateral in (("fully backed in cash", 1_020_000.0),
                         ("backed by volatile assets", 1_500_000.0),
                         ("after those assets fall 40%", 900_000.0)):
    print(f"{name:28s} collateral {collateral:>11,.0f}  "
          f"ratio {collateral / issued:>6.1%}  "
          f"{'each coin is covered' if collateral >= issued else 'NOT every coin can be redeemed'}")

You should see: a comfortable-looking 150% becoming 90% after one bad week:

fully backed in cash         collateral   1,020,000  ratio 102.0%  each coin is covered
backed by volatile assets    collateral   1,500,000  ratio 150.0%  each coin is covered
after those assets fall 40%  collateral     900,000  ratio  90.0%  NOT every coin can be redeemed

Both of the first two lines are “fully backed”, and they are not the same thing at all: cash cannot fall 40%. The practical questions for any stablecoin are what the collateral is, who has audited it, and whether you can redeem directly or only sell on a market — and if a stablecoin is backed by its own project’s token, the collateral falls at exactly the moment redemptions arrive.

If not: ValueError: Invalid format specifier means the :>6.1% was mistyped. The conditional inside the f-string needs its own quotes to differ from the ones wrapping the string.

Go: same folder. Your wallet shows coins and tokens in one list, which hides an important difference.

Do: save this as token.py and run it.

class Chain:
    """The chain knows about ONE native coin, and about contracts."""
    def __init__(self):
        self.native = {"alice": 10.0, "bob": 2.0}       # the coin itself
        self.contracts = {}

class TokenContract:
    """A token is a table INSIDE a contract, not a thing the chain knows about."""
    def __init__(self, name, owner):
        self.name, self.owner = name, owner
        self.balances = {"alice": 500.0}

chain = Chain()
chain.contracts["0xTOKEN"] = TokenContract("MyToken", owner="dev")

print("alice's coins (the chain itself) :", chain.native["alice"])
print("alice's MyToken (a contract row) :", chain.contracts["0xTOKEN"].balances["alice"])
print()
print("if the contract disappears, so does every MyToken balance:")
del chain.contracts["0xTOKEN"]
print("  alice's coins   :", chain.native["alice"])
print("  alice's MyToken :", "the contract no longer exists")

You should see: two balances that look alike in a wallet and are not:

alice's coins (the chain itself) : 10.0
alice's MyToken (a contract row) : 500.0

if the contract disappears, so does every MyToken balance:
  alice's coins   : 10.0
  alice's MyToken : the contract no longer exists

That is the coin-versus-token distinction, made concrete. A coin is what the network itself accounts for; a token is a row in somebody’s program running on that network, and it inherits every power that program’s author kept. The blockchain will faithfully protect your token balance from everyone except the contract that defines it.

If not: KeyError: '0xTOKEN' on the line before the deletion means the contract was registered under a different name — the two strings must match.

Go: same folder. People say the artwork is “on the blockchain”. Print the record and see.

Do: save this as nft.py and run it.

nft = {"token_id": 4171, "owner": "alice",
       "metadata_uri": "https://some-startup.example/api/nft/4171.json"}

print("what the blockchain actually stores:")
for key, value in nft.items():
    print(f"  {key:14s}: {value}")
print()
print("where the picture lives: at that URL, on somebody's web server")
print("if that server goes away, the chain still says alice owns token 4171,")
print("and nothing on the chain can tell you what it looked like")

You should see: three fields, none of which is an image:

what the blockchain actually stores:
  token_id      : 4171
  owner         : alice
  metadata_uri  : https://some-startup.example/api/nft/4171.json

where the picture lives: at that URL, on somebody's web server
if that server goes away, the chain still says alice owns token 4171,
and nothing on the chain can tell you what it looked like

The chain guarantees ownership of a number, permanently and provably. What that number points at is an ordinary web address, subject to expiring domains, shut-down startups and edited files. Some projects store the image on content-addressed storage, where the address is a hash of the file so it cannot be swapped — that is a meaningful difference and worth checking before buying. The question to ask of any NFT is not “is it on the blockchain” but “what exactly is, and who controls the rest?”

If not: if the dictionary prints on one line, the loop was replaced by a single print(nft) — the point is to see the fields separately.