Add regtest support

Author: jamesob

buidl/bech32.py

@@ -11,6 +11,14 @@
 
 BECH32M_CONSTANT = 0x2BC830A3
 
+PREFIX = {
+    'mainnet': 'bc',
+    'testnet': 'tb',
+    'regtest': 'bcrt',
+    'signet': 'tb',
+}
+NET_FOR_PREFIX = {v: k for k, v in PREFIX.items() if k != 'signet'}
+
 
 def uses_only_bech32_chars(string):
     return bool(BECH32_CHARS_RE.match(string.lower()))
@@ -163,10 +171,9 @@ def encode_bech32(nums):
 
 def encode_bech32_checksum(s, network="mainnet"):
     """Convert a segwit ScriptPubKey to a bech32 address"""
-    if network == "mainnet":
-        prefix = "bc"
-    else:
-        prefix = "tb"
+    prefix = PREFIX.get(network)
+    if not prefix:
+        raise ValueError(f"unrecognized network: {network}")
     version = s[0]
     if version > 0:
         version -= 0x50
@@ -181,21 +188,21 @@ def encode_bech32_checksum(s, network="mainnet"):
 
 def decode_bech32(s):
     """Returns network, segwit version and the hash from the bech32 address"""
-    hrp, raw_data = s.split("1")
-    if hrp == "bc":
-        network = "mainnet"
-    elif hrp == "tb":
-        network = "testnet"
+    regtest_prefix = PREFIX['regtest']
+    if s.startswith(regtest_prefix):
+        hrp, raw_data = regtest_prefix, s[5:]
     else:
+        hrp, raw_data = s.split("1")
+
+    network = NET_FOR_PREFIX.get(hrp)
+    if not network:
         raise ValueError(f"unknown human readable part: {hrp}")
+
     data = [BECH32_ALPHABET.index(c) for c in raw_data]
     version = data[0]
-    if version == 0:
-        if not bech32_verify_checksum(hrp, data):
-            raise ValueError(f"bad address: {s}")
-    else:
-        if not bech32m_verify_checksum(hrp, data):
-            raise ValueError(f"bad address: {s}")
+    verify_fnc = bech32_verify_checksum if version == 0 else bech32m_verify_checksum
+    if not verify_fnc(hrp, data):
+        raise ValueError(f"bad address: {s}")
     number = 0
     for digit in data[1:-6]:
         number = (number << 5) + digit

buidl/block.py

@@ -175,13 +175,16 @@ def get_outpoints(self):
 GENESIS_BLOCK_MAINNET_HEX = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c"
 GENESIS_BLOCK_TESTNET_HEX = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae18"
 GENESIS_BLOCK_SIGNET_HEX = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a008f4d5fae77031e8ad22203"
+GENESIS_BLOCK_REGTEST_HEX = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f2002000000"
 GENESIS_BLOCK_HEADERS = {
     "mainnet": Block.parse_header(hex=GENESIS_BLOCK_MAINNET_HEX),
     "testnet": Block.parse_header(hex=GENESIS_BLOCK_TESTNET_HEX),
     "signet": Block.parse_header(hex=GENESIS_BLOCK_SIGNET_HEX),
+    "regtest": Block.parse_header(hex=GENESIS_BLOCK_REGTEST_HEX),
 }
 GENESIS_BLOCK_HASH = {
     "mainnet": GENESIS_BLOCK_HEADERS["mainnet"].hash(),
     "testnet": GENESIS_BLOCK_HEADERS["testnet"].hash(),
     "signet": GENESIS_BLOCK_HEADERS["signet"].hash(),
+    "regtest": GENESIS_BLOCK_HEADERS["regtest"].hash(),
 }

buidl/hd.py

@@ -27,12 +27,14 @@
     "mainnet": bytes.fromhex("0488ade4"),
     "testnet": bytes.fromhex("04358394"),
     "signet": bytes.fromhex("04358394"),
+    "regtest": bytes.fromhex("04358394"),
 }
 
 XPUB = {
     "mainnet": bytes.fromhex("0488b21e"),
     "testnet": bytes.fromhex("043587cf"),
     "signet": bytes.fromhex("043587cf"),
+    "regtest": bytes.fromhex("043587cf"),
 }
 
 # P2PKH or P2SH, P2WPKH in P2SH, P2WPKH, Multi-signature P2WSH in P2SH, Multi-signature P2WSH
@@ -57,6 +59,7 @@
     "mainnet": "m/48h/0h/0h/2h",
     "testnet": "m/48h/1h/0h/2h",
     "signet": "m/48h/1h/0h/2h",
+    "regtest": "m/48h/1h/0h/2h",
 }
 
 
@@ -266,14 +269,20 @@ def parse(cls, s):
         return cls.raw_parse(stream)
 
     @classmethod
-    def raw_parse(cls, s):
-        """Returns a HDPrivateKey from a stream"""
+    def raw_parse(cls, s, network=None):
+        """
+        Returns a HDPrivateKey from a stream.
+
+        `network` should be specified if not mainnet, since SLIP-0132 version
+        numbers are don't differentiate between non-mainnet networks.
+        """
         # first 4 bytes are the priv_version
         priv_version = s.read(4)
         # check that the priv_version is one of the TESTNET or MAINNET
         #  private keys, if not raise a ValueError
         if priv_version in ALL_TESTNET_XPRVS:
-            network = "testnet"
+            if network is None:
+                network = "testnet"
         elif priv_version in ALL_MAINNET_XPRVS:
             network = "mainnet"
         else:
@@ -680,14 +689,20 @@ def parse(cls, s):
         return cls.raw_parse(stream)
 
     @classmethod
-    def raw_parse(cls, s):
-        """Returns a HDPublicKey from a stream"""
+    def raw_parse(cls, s, network=None):
+        """
+        Returns a HDPublicKey from a stream.
+
+        `network` should be specified if not mainnet, since SLIP-0132 version
+        numbers are don't differentiate between non-mainnet networks.
+        """
         # first 4 bytes are the pub_version
         pub_version = s.read(4)
         # check that the pub_version is one of the TESTNET or MAINNET
         #  public keys, if not raise a ValueError
         if pub_version in ALL_TESTNET_XPUBS:
-            network = "testnet"
+            if network is None:
+                network = "testnet"
         elif pub_version in ALL_MAINNET_XPUBS:
             network = "mainnet"
         else:

buidl/network.py

@@ -26,11 +26,13 @@
     "mainnet": b"\xf9\xbe\xb4\xd9",
     "testnet": b"\x0b\x11\x09\x07",
     "signet": b"\x0a\x03\xcf\x40",
+    "regtest": b"\xfa\xbf\xb5\xda",
 }
 PORT = {
     "mainnet": 8333,
     "testnet": 18333,
     "signet": 38333,
+    "regtest": 18444,
 }
 
 

buidl/pecc.py

@@ -617,7 +617,14 @@ def tweaked(self, tweak):
 
     @classmethod
     def parse(cls, wif):
-        """Converts WIF to a PrivateKey object"""
+        """
+        Converts WIF to a PrivateKey object.
+
+        Note that this doesn't differentiate between non-mainnet networks. Since
+        this class doesn't generate anything downstream of the particular network
+        (e.g. addresses), it shouldn't be a problem, however the network inferred
+        here cannot be relied upon if parsing a non-mainnet key.
+        """
         raw = raw_decode_base58(wif)
         if len(raw) == 34:
             compressed = True

buidl/test/test_bech32.py

@@ -15,45 +15,54 @@ def test_bech32(self):
                 "mainnet": "bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3",
                 "testnet": "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
                 "signet": "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
+                "regtest": "bcrt1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qzf4jry",
             },
             {
                 "hex_script": "00200000000000000000000000000000000000000000000000000000000000000000",
                 "mainnet": "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqthqst8",
                 "testnet": "tb1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqulkl3g",
                 "signet": "tb1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqulkl3g",
+                "regtest": "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3xueyj",
             },
             {
                 "hex_script": "00140000000000000000000000000000000000000000",
                 "mainnet": "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq9e75rs",
                 "testnet": "tb1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq0l98cr",
                 "signet": "tb1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq0l98cr",
+                "regtest": "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqdku202",
             },
             {
                 "hex_script": "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433",
                 "mainnet": "bc1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvses5wp4dt",
                 "testnet": "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
                 "signet": "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
+                "regtest": "bcrt1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvseswlauz7",
             },
             {
                 "hex_script": "5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6",
                 "mainnet": "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y",
                 "testnet": "tb1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kxwkgjv",
                 "signet": "tb1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kxwkgjv",
+                "regtest": "bcrt1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k0ylj56",
             },
             {
                 "hex_script": "5120000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433",
                 "mainnet": "bc1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvses7epu4h",
                 "testnet": "tb1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesf3hn0c",
                 "signet": "tb1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesf3hn0c",
+                "regtest": "bcrt1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesyga46z",
             },
             {
                 "hex_script": "512079be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
                 "mainnet": "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqzk5jj0",
                 "testnet": "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47zagq",
                 "signet": "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47zagq",
+                "regtest": "bcrt1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqc8gma6",
             },
         ]
         for test in tests:
+            # Special-case signet here because it will decode as a testnet-inferred
+            # address.
             raw = bytes.fromhex(test["hex_script"])
             want = test["signet"]
             version = BECH32_ALPHABET.index(want[3:4])
@@ -63,9 +72,15 @@ def test_bech32(self):
             self.assertEqual(got_network, "testnet")
             self.assertEqual(got_version, version)
             self.assertEqual(got_raw, raw[2:])
-            for network in ("mainnet", "testnet"):
+
+            for network in ("mainnet", "testnet", "regtest"):
+                ver_index = 3
+                if network == "regtest":
+                    # Account for the two extra letters ("rt") in the regtest prefix.
+                    ver_index += 2
+
                 want = test[network]
-                version = BECH32_ALPHABET.index(want[3:4])
+                version = BECH32_ALPHABET.index(want[ver_index])
                 result = encode_bech32_checksum(raw, network=network)
                 self.assertEqual(result, want)
                 got_network, got_version, got_raw = decode_bech32(result)