🪙 Bitcoin with Python: read the price, then trade it · บิตคอยน์ด้วย Python: อ่านราคา แล้วเทรดมัน · 用 Python 玩比特币：先读价格，再交易

1 Ask Bitkub for the price · ถามราคาจาก Bitkub · 向 Bitkub 要价格

📄 NEW FILE · price1.py

"""price1.py — what is one bitcoin worth in baht, right now?"""
import json
import urllib.request

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"


def main():
    """Ask Bitkub for the bitcoin price and print it."""
    with urllib.request.urlopen(BITKUB + "?sym=BTC_THB", timeout=30) as response:
        coins = json.load(response)

    # Bitkub sends back a list, even when you ask about one coin.
    bitcoin = coins[0]

    # Every number arrives as text. float() turns it into a number you can use.
    price = float(bitcoin["last"])

    print("1 bitcoin =", price, "baht")
    print("100 baht  =", 100 / price, "bitcoin")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

1 bitcoin = 2831623.43 baht
100 baht  = 3.531543034308061e-05 bitcoin

2 There is no single price · ไม่มีราคาเดียว · 并没有"一个价格"

📄 NEW FILE · price2.py

"""price2.py — the two prices behind "the price"."""
import json
import urllib.request

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"
COIN = "BTC_THB"


def ticker(symbol):
    """One coin's numbers from Bitkub. No key and no account needed."""
    with urllib.request.urlopen(BITKUB + "?sym=" + symbol, timeout=30) as response:
        return json.load(response)[0]


def main():
    """Show what you would pay, what you would get, and the gap between."""
    coin = ticker(COIN)

    # There is never one price. There is a price to buy and a price to sell.
    buy_at = float(coin["lowest_ask"])
    sell_at = float(coin["highest_bid"])
    gap = buy_at - sell_at

    print("you buy at :", buy_at)
    print("you sell at:", sell_at)
    print("the gap    :", round(gap, 2), "baht")

    # Buy and sell at once and you lose the gap. That is the cost of a round trip.
    print("the gap is :", round(gap / buy_at * 100, 3), "percent of the price")
    print()
    print("24 hour high:", coin["high_24_hr"])
    print("24 hour low :", coin["low_24_hr"])
    print("24 hour move:", coin["percent_change"], "percent")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

you buy at : 2832079.66
you sell at: 2831323.67
the gap    : 755.99 baht
the gap is : 0.027 percent of the price

24 hour high: 2836037.62
24 hour low : 2671850.12
24 hour move: 5.95 percent

3 Every coin, sorted by today's move · เรียงทุกเหรียญตามการเคลื่อนไหววันนี้ · 把所有币按今天的涨跌排序

📄 NEW FILE · price3.py

"""price3.py — which coins moved the most today?"""
import json
import urllib.request

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"


def all_coins():
    """Every coin Bitkub lists, in one request. Leave off sym to get them all."""
    with urllib.request.urlopen(BITKUB, timeout=30) as response:
        return json.load(response)


def movement(coin):
    """How far this coin moved today. sort() calls this on every coin."""
    return float(coin["percent_change"])


def show(coin):
    """One tidy line for one coin."""
    name = coin["symbol"].ljust(12)
    change = coin["percent_change"].rjust(8)
    print("   ", name, change, "%   last:", coin["last"])


def main():
    """Sort every coin by today's move, then print both ends of the list."""
    coins = all_coins()
    print("Bitkub lists", len(coins), "coins against the baht")
    print()

    coins.sort(key=movement, reverse=True)

    print("up the most today:")
    for coin in coins[:5]:
        show(coin)

    print()
    print("down the most today:")
    for coin in coins[-5:]:
        show(coin)


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

Bitkub lists 366 coins against the baht

up the most today:
    ZETA_THB        79.14 %   last: 2.25
    ASP_THB         38.86 %   last: 0.4513
    EDEN_THB        29.81 %   last: 2.013

down the most today:
    CELR_THB       -12.84 %   last: 0.11809
    ACX_THB        -21.4 %   last: 1.2004

4 The queue, and what your money really buys · คิวคำสั่ง และเงินของคุณซื้อได้จริงเท่าไร · 排队的单子，和你的钱真正买得到多少

📄 NEW FILE · book1.py

"""book1.py — the queue of real orders, and what your money would really buy."""
import json
import urllib.request

DEPTH = "https://api.bitkub.com/api/v3/market/depth"
SPEND = 500000.0      # baht


def order_book(symbol, rows=30):
    """The orders people are waiting with. asks are sellers, bids are buyers."""
    url = DEPTH + "?sym=" + symbol + "&lmt=" + str(rows)
    with urllib.request.urlopen(url, timeout=30) as response:
        return json.load(response)["result"]


def main():
    """Show both queues, then walk the sell queue with a pile of baht."""
    book = order_book("BTC_THB")

    print("people selling (asks) - you buy from these:")
    for price, amount in book["asks"][:5]:
        print("   ", price, "for", amount, "BTC")

    print()
    print("people buying (bids) - you sell to these:")
    for price, amount in book["bids"][:5]:
        print("   ", price, "for", amount, "BTC")

    # A market order eats this queue from the top down. The cheap sellers go
    # first, then you pay the dearer ones. That is why a big order costs more
    # than the price on the screen.
    spent = 0.0
    bought = 0.0
    for price, amount in book["asks"]:
        if spent >= SPEND:
            break
        cost = price * amount
        if spent + cost > SPEND:
            cost = SPEND - spent
        spent = spent + cost
        bought = bought + cost / price

    print()
    print("screen price   :", book["asks"][0][0])
    print("spending       :", SPEND, "baht")
    print("you would get  :", bought, "BTC")
    print("average paid   :", round(spent / bought, 2))
    print("worse than screen by:", round(spent / bought - book["asks"][0][0], 2), "baht")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

screen price   : 2829404.79
spending       : 500000.0 baht
you would get  : 0.17669767911645334 BTC
average paid   : 2829691.95
worse than screen by: 287.16 baht

5 Write the price down · จดราคาเอาไว้ · 把价格记下来

📄 NEW FILE · save1.py

"""save1.py — write the price down, so you can watch it move."""
import json
import time
import urllib.request
from pathlib import Path

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"
HISTORY = Path("btc_history.txt")


def price_now():
    """The last traded price of one bitcoin, in baht."""
    with urllib.request.urlopen(BITKUB + "?sym=BTC_THB", timeout=30) as response:
        return float(json.load(response)[0]["last"])


def main():
    """Add one line to the history file: the time, and the price."""
    price = price_now()
    when = time.strftime("%Y-%m-%d %H:%M:%S")

    # "a" adds to the end, so every earlier line stays where it is.
    with open(HISTORY, "a", encoding="utf-8") as history:
        history.write(when + " " + str(price) + "\n")

    lines = HISTORY.read_text(encoding="utf-8").splitlines()
    print("wrote:", when, price)
    print(HISTORY.name, "now holds", len(lines), "lines")


if __name__ == "__main__":
    main()

6 Draw it with characters · วาดมันด้วยตัวอักษร · 用字符把它画出来

📄 NEW FILE · chart1.py

"""chart1.py — draw the saved history as a picture made of characters."""
from pathlib import Path

HISTORY = Path("btc_history.txt")
WIDTH = 40


def read_history():
    """Every saved line, as (when, price) pairs."""
    rows = []
    for line in HISTORY.read_text(encoding="utf-8").splitlines():
        parts = line.split()
        when = parts[1]              # parts[0] is the date, parts[1] the clock
        price = float(parts[2])
        rows.append((when, price))
    return rows


def main():
    """Scale every price between the lowest and the highest, then draw a bar."""
    rows = read_history()
    if len(rows) < 2:
        raise SystemExit("Run save1.py a few times first.")

    prices = []
    for when, price in rows:
        prices.append(price)

    low = min(prices)
    high = max(prices)
    print("low :", low)
    print("high:", high)
    print()

    for when, price in rows:
        if high == low:
            # Every price the same. One flat line is the honest picture.
            steps = 1
        else:
            steps = int((price - low) / (high - low) * WIDTH) + 1
        print(when, "|" + "#" * steps, price)


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · from six real saved prices

low : 2826560.18
high: 2828945.91

19:42:22 |################# 2827532.12
19:42:27 |# 2826560.18
19:42:31 |######################################### 2828945.91
19:42:35 |######################################### 2828945.91
19:42:40 |################################## 2828535.18
19:42:44 |################################## 2828535.18

7 Tell me when it crosses a line · บอกฉันเมื่อมันข้ามเส้น · 越线的时候告诉我

📄 NEW FILE · watch1.py

"""watch1.py — keep looking, and say something when the price crosses a line."""
import json
import time
import urllib.request

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"

HIGH_LINE = 2830000      # tell me if it goes above this
LOW_LINE = 2700000       # tell me if it falls below this
EVERY = 10               # seconds between looks
LOOKS = 3                # how many times to look


def price_now():
    """The last traded price of one bitcoin, in baht."""
    with urllib.request.urlopen(BITKUB + "?sym=BTC_THB", timeout=30) as response:
        return float(json.load(response)[0]["last"])


def main():
    """Look a few times, and report where the price sits each time."""
    for look in range(LOOKS):
        price = price_now()
        clock = time.strftime("%H:%M:%S")

        if price > HIGH_LINE:
            print(clock, price, "ABOVE your line")
        elif price < LOW_LINE:
            print(clock, price, "BELOW your line")
        else:
            print(clock, price, "between your lines")

        # Do not sleep after the last look. Nobody is waiting for it.
        if look < LOOKS - 1:
            time.sleep(EVERY)


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

19:43:36 2828535.18 between your lines
19:43:46 2827096.61 between your lines
19:43:56 2827096.61 between your lines

8 Prove your key works · พิสูจน์ว่าคีย์ใช้ได้ · 先证明你的密钥能用

📄 NEW FILE · sign1.py

"""sign1.py — prove your key works, before any money is involved."""
import hashlib
import hmac
import json
import os
import urllib.error
import urllib.request

HOST = "https://api.bitkub.com"
KEY = os.environ["BITKUB_KEY"]
SECRET = os.environ["BITKUB_SECRET"]

# What Bitkub says when it will not believe you.
PROBLEMS = {
    2: "the API key header is missing",
    3: "the key itself is wrong",
    4: "the key is not switched on yet",
    5: "this computer's address is not on your allowed list",
    6: "the signature is wrong - check the signed string",
    7: "the timestamp header is missing",
    8: "the timestamp is wrong - use server_time(), not your own clock",
    52: "the key is real, but has no permission for this",
}


def server_time():
    """Bitkub's own clock, in milliseconds. Sign with this, not your laptop's."""
    with urllib.request.urlopen(HOST + "/api/v3/servertime", timeout=30) as response:
        return response.read().decode()


def signed_get(path, query=""):
    """A GET that Bitkub will believe came from you."""
    stamp = server_time()

    # This exact string is what gets signed: time, then METHOD, then the path,
    # then the query. No spaces, no commas. One wrong character gives error 6.
    message = stamp + "GET" + path + query
    signature = hmac.new(SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()

    request = urllib.request.Request(HOST + path + query, headers={
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-BTK-APIKEY": KEY,
        "X-BTK-TIMESTAMP": stamp,
        "X-BTK-SIGN": signature,
    })
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.load(response)
    except urllib.error.HTTPError as refused:
        # A key Bitkub will not accept comes back as 401, and urllib calls that
        # an error and stops. The reason is in the body, so read the body.
        return json.loads(refused.read())


def main():
    """Ask for your open orders. It changes nothing, and it proves the key."""
    answer = signed_get("/api/v3/market/my-open-orders", "?sym=btc_thb")
    code = answer.get("error", 0)

    if code == 0:
        print("your key works.")
        print("open orders right now:", len(answer["result"]))
        return

    print("Bitkub said no. error", code)
    print(PROBLEMS.get(code, "look this number up in the error table"))


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run, with a key we made up

Bitkub said no. error 3
the key itself is wrong

9 What you actually hold · คุณถืออะไรอยู่จริง ๆ · 你手上到底有什么

📄 NEW FILE · wallet1.py

"""wallet1.py — what is actually in your Bitkub account."""
import hashlib
import hmac
import json
import os
import urllib.error
import urllib.request

HOST = "https://api.bitkub.com"
KEY = os.environ["BITKUB_KEY"]
SECRET = os.environ["BITKUB_SECRET"]


def server_time():
    """Bitkub's own clock, in milliseconds. Sign with this, not your laptop's."""
    with urllib.request.urlopen(HOST + "/api/v3/servertime", timeout=30) as response:
        return response.read().decode()


def signed_get(path, query=""):
    """A GET that Bitkub will believe came from you."""
    stamp = server_time()
    message = stamp + "GET" + path + query
    signature = hmac.new(SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()

    request = urllib.request.Request(HOST + path + query, headers={
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-BTK-APIKEY": KEY,
        "X-BTK-TIMESTAMP": stamp,
        "X-BTK-SIGN": signature,
    })
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.load(response)
    except urllib.error.HTTPError as refused:
        return json.loads(refused.read())


def main():
    """Print every coin you hold, and the baht sitting beside them."""
    answer = signed_get("/api/v4/wallet/balances")

    # Careful: the wallet is version 4, and version 4 answers differently.
    # v3 says {"error": 0, "result": ...}. v4 says {"code": "0", "data": ...}.
    if answer.get("code") != "0":
        print("Bitkub said no:", answer.get("code"), "-", answer.get("message"))
        return

    print("currency   available        reserved")
    for row in answer["data"]:
        if float(row["total"]) == 0:
            continue                      # skip the coins you do not hold
        print(row["currency"].ljust(10), row["available"].ljust(16), row["reserved"])


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run, with a key we made up

Bitkub said no: A1003-MK - Invalid API key

10 A real order that cannot fill · คำสั่งจริงที่ไม่มีทางถูกจับคู่ · 一个成交不了的真实订单

📄 NEW FILE · buy1.py

"""buy1.py — place a real order, priced so low that it cannot fill."""
import hashlib
import hmac
import json
import os
import urllib.error
import urllib.request

HOST = "https://api.bitkub.com"
KEY = os.environ["BITKUB_KEY"]
SECRET = os.environ["BITKUB_SECRET"]

COIN = "btc_thb"
SPEND = 20.0        # baht to offer. Bitkub's smallest order is 10 baht.
FRACTION = 0.5      # offer half the going rate, so nobody takes it


def server_time():
    """Bitkub's own clock, in milliseconds. Sign with this, not your laptop's."""
    with urllib.request.urlopen(HOST + "/api/v3/servertime", timeout=30) as response:
        return response.read().decode()


def price_now():
    """The last traded price of one bitcoin, in baht."""
    url = HOST + "/api/v3/market/ticker?sym=BTC_THB"
    with urllib.request.urlopen(url, timeout=30) as response:
        return float(json.load(response)[0]["last"])


def signed_post(path, body):
    """A POST that Bitkub will believe came from you."""
    stamp = server_time()

    # The text you sign and the text you send must be the same characters.
    # Build the JSON once, sign that, send that. Building it twice gives error 6.
    payload = json.dumps(body)
    message = stamp + "POST" + path + payload
    signature = hmac.new(SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()

    request = urllib.request.Request(HOST + path, data=payload.encode(), headers={
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-BTK-APIKEY": KEY,
        "X-BTK-TIMESTAMP": stamp,
        "X-BTK-SIGN": signature,
    })
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.load(response)
    except urllib.error.HTTPError as refused:
        return json.loads(refused.read())


def main():
    """Show the offer, ask a person, then send it."""
    price = price_now()
    offer = round(price * FRACTION, 2)

    print("bitcoin is trading at:", price, "baht")
    print("you are offering     :", offer, "baht for one bitcoin")
    print("you are spending     :", SPEND, "baht")
    print()
    print("Nobody sells at half price, so this order will sit and wait.")
    print("That is the point. You can look at it, then take it back.")
    print()

    # A person reads this before any real money is committed.
    if input("place this real order? type yes: ").strip().lower() != "yes":
        raise SystemExit("Nothing was placed.")

    answer = signed_post("/api/v3/market/place-bid", {
        "sym": COIN,
        "amt": SPEND,
        "rat": offer,
        "typ": "limit",
    })

    if answer.get("error", 0) != 0:
        print("Bitkub said no. error", answer["error"])
        return

    order = answer["result"]
    print("order placed. its id is", order["id"])
    print("your", SPEND, "baht is held, not spent. Run orders1.py to take it back.")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run, with a key we made up

bitcoin is trading at: 2830000.0 baht
you are offering     : 1415000.0 baht for one bitcoin
you are spending     : 20.0 baht

Nobody sells at half price, so this order will sit and wait.
That is the point. You can look at it, then take it back.

place this real order? type yes: Bitkub said no. error 3

11 See it, then take it back · ดูมัน แล้วดึงมันกลับ · 看着它，然后撤回来

📄 NEW FILE · orders1.py

"""orders1.py — see your waiting orders, and take them back."""
import hashlib
import hmac
import json
import os
import urllib.error
import urllib.request

HOST = "https://api.bitkub.com"
KEY = os.environ["BITKUB_KEY"]
SECRET = os.environ["BITKUB_SECRET"]

COIN = "btc_thb"


def server_time():
    """Bitkub's own clock, in milliseconds. Sign with this, not your laptop's."""
    with urllib.request.urlopen(HOST + "/api/v3/servertime", timeout=30) as response:
        return response.read().decode()


def sign(stamp, method, path, tail):
    """The one string Bitkub signs: time, method, path, then query or body."""
    message = stamp + method + path + tail
    return hmac.new(SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()


def ask(method, path, query="", body=None):
    """One signed request. GET carries a query, POST carries a body."""
    stamp = server_time()
    payload = json.dumps(body) if body else ""
    signature = sign(stamp, method, path, payload if body else query)

    request = urllib.request.Request(
        HOST + path + query,
        data=payload.encode() if body else None,
        headers={
            "Accept": "application/json",
            "Content-Type": "application/json",
            "X-BTK-APIKEY": KEY,
            "X-BTK-TIMESTAMP": stamp,
            "X-BTK-SIGN": signature,
        })
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.load(response)
    except urllib.error.HTTPError as refused:
        return json.loads(refused.read())


def main():
    """List what is waiting, then offer to cancel all of it."""
    answer = ask("GET", "/api/v3/market/my-open-orders", query="?sym=" + COIN)
    if answer.get("error", 0) != 0:
        print("Bitkub said no. error", answer["error"])
        return

    orders = answer["result"]
    if not orders:
        print("Nothing is waiting.")
        return

    print(len(orders), "order(s) waiting:")
    for order in orders:
        print("   id:", order["id"], "| side:", order["side"],
              "| rate:", order["rate"], "| amount:", order["amount"])

    print()
    if input("cancel all of them? type yes: ").strip().lower() != "yes":
        raise SystemExit("Left alone.")

    for order in orders:
        answer = ask("POST", "/api/v3/market/cancel-order", body={
            "sym": COIN,
            "id": str(order["id"]),
            "sd": order["side"].lower(),
        })
        if answer.get("error", 0) == 0:
            print("cancelled", order["id"])
        else:
            print("could not cancel", order["id"], "- error", answer["error"])


if __name__ == "__main__":
    main()

12 Price it in baht, charge it in bitcoin · ตั้งราคาเป็นบาท เก็บเงินเป็นบิตคอยน์ · 用泰铢定价，用比特币收款

📄 NEW FILE · shop1.py

"""shop1.py — turn a price in baht into a bitcoin payment request."""
import json
import random
import urllib.parse
import urllib.request

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"

# Put your own receiving address here. This one is famous and not yours.
ADDRESS = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
PRICE_THB = 250.0
ITEM = "One bag of Doi Chaang coffee"

SATOSHIS_IN_ONE = 100000000


def btc_price():
    """One bitcoin, in baht, right now. The same call as step 1."""
    with urllib.request.urlopen(BITKUB + "?sym=BTC_THB", timeout=30) as response:
        return float(json.load(response)[0]["last"])


def make_invoice(baht):
    """Baht in, satoshis out. The last few satoshis make this order unique."""
    rate = btc_price()
    satoshis = int(baht / rate * SATOSHIS_IN_ONE)

    # Two people buying the same coffee would owe exactly the same amount, and
    # you could not tell their two payments apart. A few spare satoshis can.
    return rate, satoshis + random.randint(1, 999)


def main():
    """Price the item, then print the link a wallet understands."""
    rate, satoshis = make_invoice(PRICE_THB)
    amount = satoshis / SATOSHIS_IN_ONE

    # A bitcoin: link. A phone opens it in a wallet, amount already filled in.
    uri = "bitcoin:" + ADDRESS + "?" + urllib.parse.urlencode({
        "amount": format(amount, ".8f"),
        "label": ITEM,
    })

    print("item      :", ITEM)
    print("price     :", PRICE_THB, "baht")
    print("rate today:", rate, "baht for one bitcoin")
    print("satoshis  :", satoshis)
    print("amount    :", format(amount, ".8f"), "BTC")
    print()
    print(uri)


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

item      : One bag of Doi Chaang coffee
price     : 250.0 baht
rate today: 2833237.15 baht for one bitcoin
satoshis  : 9242
amount    : 0.00009242 BTC

bitcoin:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa?amount=0.00009242&label=One+bag+of+Doi+Chaang+coffee

13 A page that watches for its own payment · หน้าเว็บที่เฝ้าดูเงินของตัวเอง · 一个会自己等钱的页面

📄 NEW FILE · shop2.py

"""shop2.py — write a payment page that watches the chain by itself."""
import io
import json
import random
import urllib.parse
import urllib.request
from pathlib import Path

import qrcode
import qrcode.image.svg

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"

ADDRESS = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
PRICE_THB = 250.0
ITEM = "One bag of Doi Chaang coffee"

SATOSHIS_IN_ONE = 100000000
PAGE = Path("pay.html")

# No server anywhere in this file. Python writes the page, and after that the
# page looks after itself in the customer's browser.
TEMPLATE = """<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Pay with bitcoin</title>
<style>
  body { font-family: system-ui, sans-serif; max-width: 30rem; margin: 0 auto;
         padding: 1.5rem; background: #fbfaf7; color: #222; }
  .qr { width: 15rem; height: 15rem; }
  code { background: #eee; padding: 2px 5px; border-radius: 4px;
         word-break: break-all; font-size: 0.9rem; }
  #status { padding: 0.8rem 1rem; border-radius: 8px; font-weight: 600;
            background: #eee; margin: 1rem 0; }
  .waiting { background: #fff4d6 !important; }
  .seen { background: #dbeafe !important; }
  .confirmed { background: #d9f5df !important; }
</style>
</head>
<body>
  <h1>__ITEM__</h1>
  <p>__PRICE__ baht &middot; <strong>__AMOUNT__ BTC</strong></p>

  <a href="__URI__">__QR__</a>

  <p>Send exactly <code>__AMOUNT__</code> BTC to:</p>
  <p><code>__ADDRESS__</code></p>

  <div id="status" class="waiting">Waiting for your payment...</div>

  <script>
  // The blockchain is public, so a page with no server can read it.
  var ADDRESS = "__ADDRESS__";
  var SATOSHIS = __SATOSHIS__;
  var API = "https://mempool.space/api/address/" + ADDRESS + "/txs";

  function show(state, words) {
    var box = document.getElementById("status");
    box.className = state;
    box.textContent = words;
  }

  function look() {
    fetch(API).then(function (r) { return r.json(); }).then(function (txs) {
      var best = "waiting";
      for (var i = 0; i < txs.length; i++) {
        var outputs = txs[i].vout;
        for (var j = 0; j < outputs.length; j++) {
          // The exact amount is how we know this payment is for this order.
          if (outputs[j].scriptpubkey_address === ADDRESS &&
              outputs[j].value === SATOSHIS) {
            // Unconfirmed ones are listed first, so do not stop at the first
            // match. A payment in a block beats one that is only seen.
            if (txs[i].status.confirmed) { best = "confirmed"; }
            else if (best === "waiting") { best = "seen"; }
          }
        }
      }
      if (best === "confirmed") {
        show("confirmed", "Paid, and in a block. Thank you!");
      } else if (best === "seen") {
        show("seen", "Payment seen. Waiting for a block...");
      } else {
        show("waiting", "Waiting for your payment...");
      }
    }).catch(function () {
      show("waiting", "Could not reach the chain. Trying again...");
    });
  }

  look();
  setInterval(look, 10000);
  </script>
</body>
</html>
"""


def btc_price():
    """One bitcoin, in baht, right now."""
    with urllib.request.urlopen(BITKUB + "?sym=BTC_THB", timeout=30) as response:
        return float(json.load(response)[0]["last"])


def make_invoice(baht):
    """Baht in, satoshis out. The last few satoshis make this order unique."""
    rate = btc_price()
    satoshis = int(baht / rate * SATOSHIS_IN_ONE)
    return rate, satoshis + random.randint(1, 999)


def qr_svg(text):
    """A QR picture as SVG text, ready to drop straight into the page."""
    picture = qrcode.make(text, image_factory=qrcode.image.svg.SvgPathImage)
    holder = io.BytesIO()
    picture.save(holder)

    # Cut off the XML header. Inside HTML the <svg> tag alone is enough.
    svg = holder.getvalue().decode()
    svg = svg[svg.index("<svg"):]
    return svg.replace("<svg ", '<svg class="qr" ', 1)


def main():
    """Price it, draw it, and write one file you can upload anywhere."""
    rate, satoshis = make_invoice(PRICE_THB)
    amount = format(satoshis / SATOSHIS_IN_ONE, ".8f")

    uri = "bitcoin:" + ADDRESS + "?" + urllib.parse.urlencode({
        "amount": amount, "label": ITEM})

    page = TEMPLATE
    page = page.replace("__ITEM__", ITEM)
    page = page.replace("__PRICE__", str(PRICE_THB))
    page = page.replace("__AMOUNT__", amount)
    page = page.replace("__ADDRESS__", ADDRESS)
    page = page.replace("__SATOSHIS__", str(satoshis))
    page = page.replace("__URI__", uri)
    page = page.replace("__QR__", qr_svg(uri))

    PAGE.write_text(page, encoding="utf-8")

    print("rate today:", rate, "baht for one bitcoin")
    print("wants     :", satoshis, "satoshis =", amount, "BTC")
    print("wrote     :", PAGE.name, len(page), "characters")
    print()
    print("Put that one file on GitHub Pages. There is no server to run.")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run

rate today: 2832246.69 baht for one bitcoin
wants     : 9687 satoshis = 0.00009687 BTC
wrote     : pay.html 16042 characters

Put that one file on GitHub Pages. There is no server to run.

14 Check it yourself before you post the parcel · ตรวจเองก่อนส่งของ · 寄货之前，自己核一遍

📄 NEW FILE · paid1.py

"""paid1.py — check the payment yourself, because a web page can be edited."""
import json
import urllib.request

ADDRESS_API = "https://mempool.space/api/address/"
HEIGHT_API = "https://mempool.space/api/blocks/tip/height"

ADDRESS = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
WANT_SATOSHIS = 546        # the exact amount that order asked for
SAFE_BLOCKS = 3            # how many blocks before you post the parcel


def payments_to(address):
    """Every recent transaction touching this address."""
    with urllib.request.urlopen(ADDRESS_API + address + "/txs", timeout=40) as response:
        return json.load(response)


def tip_height():
    """The number of the newest block. Needed to count confirmations."""
    with urllib.request.urlopen(HEIGHT_API, timeout=30) as response:
        return int(response.read())


def find_payment(address, satoshis):
    """Look for one payment of this exact amount. Returns (state, blocks, txid)."""
    tip = tip_height()
    best = ("waiting", 0, None)

    for transaction in payments_to(address):
        for output in transaction["vout"]:
            if output.get("scriptpubkey_address") != address:
                continue
            if output["value"] != satoshis:
                continue

            status = transaction["status"]
            if not status["confirmed"]:
                if best[0] == "waiting":
                    best = ("seen", 0, transaction["txid"])
                continue

            # Your block counts as one, so add one to the difference.
            blocks = tip - status["block_height"] + 1
            if blocks > best[1]:
                best = ("confirmed", blocks, transaction["txid"])

    return best


def main():
    """Say plainly whether this order is safe to post."""
    state, blocks, txid = find_payment(ADDRESS, WANT_SATOSHIS)

    if state == "waiting":
        print("No payment of", WANT_SATOSHIS, "satoshis yet.")
        return

    print("found:", txid)
    if state == "seen":
        print("It is on the network, but not in a block yet.")
        print("Do not post anything. A payment like this can still disappear.")
        return

    print("blocks deep:", blocks)
    if blocks >= SAFE_BLOCKS:
        print("Safe to post the parcel.")
    else:
        print("Wait for", SAFE_BLOCKS - blocks, "more block(s) before you post.")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real run, against a real paid address

found: fbb68abf3c908cfb1b7a86849934d915ccc4845e41cc9a70e1f2b6012566ab6d
blocks deep: 150
Safe to post the parcel.