pabtc 1.2.2__tar.gz

pabtc-1.2.2/.gitignore

@@ -0,0 +1,4 @@
+/.pytest_cache
+/build
+/dist
+/pybtc.egg-info

pabtc-1.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mohanson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pabtc-1.2.2/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.3
+Name: pabtc
+Version: 1.2.2
+Summary: Plbtc: bitcoin library for humans
+Project-URL: homepage, https://github.com/mohanson/pabtc
+Author-email: Mohanson <mohanson@outlook.com>
+License: MIT License
+        
+        Copyright (c) 2023 Mohanson
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Pabtc: Bitcoin Library For Humans
+
+Pabtc is a project that aims to provide human-friendly interfaces for common btc operations. Using pabtc, you can easily and happily complete everything you want to do on btc.
+
+Features:
+
+- No third-party dependencies, everything is visible.
+- Incredibly simple, even a cat knows how to use it.
+
+## Installation
+
+```sh
+$ pip install pabtc
+# or
+$ git clone https://github.com/mohanson/pabtc
+$ cd pabtc
+$ python -m pip install --editable .
+```
+
+## Usage
+
+By default, pabtc is configured on the develop. To switch networks, use `pabtc.config.current = pabtc.config.mainnet`.
+
+**example/addr.py**
+
+Calculate the address from a private key.
+
+```sh
+$ python example/addr.py --net mainnet --prikey 1
+
+# p2pkh       1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
+# p2sh-p2wpkh 3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN
+# p2wpkh      bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4
+# p2tr        bc1pmfr3p9j00pfxjh0zmgp99y8zftmd3s5pmedqhyptwy6lm87hf5sspknck9
+```
+
+**example/message.py**
+
+Sign a message with the private key and verify it.
+
+```sh
+$ python example/message.py --prikey 1 --msg pybtc
+# ICvzXjwjJVMilSGyMqwlqMTuGF6UMwddFJzVmm0Di5qNnqkBRKP8Pldm3YbOskg3ewV1tszVLy8gVX1u+qFrx6o=
+
+$ python example/message.py --prikey 1 --msg pybtc --sig ICvzXjwjJVMilSGyMqwlqMTuGF6UMwddFJzVmm0Di5qNnqkBRKP8Pldm3YbOskg3ewV1tszVLy8gVX1u+qFrx6o=
+# True
+```
+
+
+**example/taproot.py**
+
+This example demonstrates how to create a P2TR script with two script spending paths: p2pk and p2ms(2-of-2 multisig).
+
+```sh
+$ python example/taproot.py
+```
+
+**example/transfer.py**
+
+Transfer Bitcoin to another account. Pybtc supports four common types of Bitcoin transactions: P2PKH, P2SH-P2WPKH, P2WPKH, and P2TR. For more complex account types, such as P2SH-P2MS, please refer to [test/test_wallet.py](test/test_wallet.py).
+
+```sh
+$ python example/transfer.py --net develop --prikey 1 --script-type p2pkh --to mg8Jz5776UdyiYcBb9Z873NTozEiADRW5H --value 0.1
+
+# 0x039d1b0fe969d33341a7db9ddd236f632d6851292200603abc5a6c7738bf3079
+```
+
+Before using this script, you first need to execute the code in the Test section. This is because pybtc requires the bitcoin core wallet to provide an account's utxo set.
+
+## Test
+
+The testing of this project relies on regtest. You can set up the regtest node using the following steps:
+
+```sh
+$ wget https://bitcoincore.org/bin/bitcoin-core-27.1/bitcoin-27.1-x86_64-linux-gnu.tar.gz
+$ tar -xvf bitcoin-27.1-x86_64-linux-gnu.tar.gz
+$ cp -R bitcoin-27.1 ~/app/bitcoin # Install to the target location.
+
+$ mkdir ~/.bitcoin
+$ echo "chain=regtest" >> ~/.bitcoin/bitcoin.conf
+$ echo "rpcpassword=pass" >> ~/.bitcoin/bitcoin.conf
+$ echo "rpcuser=user" >> ~/.bitcoin/bitcoin.conf
+$ echo "txindex=1" >> ~/.bitcoin/bitcoin.conf
+
+$ bitcoind
+# Create default wallets
+$ python example/regtest.py
+$ pytest -v
+```
+
+## License
+
+MIT

pabtc-1.2.2/README.md

@@ -0,0 +1,93 @@
+# Pabtc: Bitcoin Library For Humans
+
+Pabtc is a project that aims to provide human-friendly interfaces for common btc operations. Using pabtc, you can easily and happily complete everything you want to do on btc.
+
+Features:
+
+- No third-party dependencies, everything is visible.
+- Incredibly simple, even a cat knows how to use it.
+
+## Installation
+
+```sh
+$ pip install pabtc
+# or
+$ git clone https://github.com/mohanson/pabtc
+$ cd pabtc
+$ python -m pip install --editable .
+```
+
+## Usage
+
+By default, pabtc is configured on the develop. To switch networks, use `pabtc.config.current = pabtc.config.mainnet`.
+
+**example/addr.py**
+
+Calculate the address from a private key.
+
+```sh
+$ python example/addr.py --net mainnet --prikey 1
+
+# p2pkh       1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
+# p2sh-p2wpkh 3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN
+# p2wpkh      bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4
+# p2tr        bc1pmfr3p9j00pfxjh0zmgp99y8zftmd3s5pmedqhyptwy6lm87hf5sspknck9
+```
+
+**example/message.py**
+
+Sign a message with the private key and verify it.
+
+```sh
+$ python example/message.py --prikey 1 --msg pybtc
+# ICvzXjwjJVMilSGyMqwlqMTuGF6UMwddFJzVmm0Di5qNnqkBRKP8Pldm3YbOskg3ewV1tszVLy8gVX1u+qFrx6o=
+
+$ python example/message.py --prikey 1 --msg pybtc --sig ICvzXjwjJVMilSGyMqwlqMTuGF6UMwddFJzVmm0Di5qNnqkBRKP8Pldm3YbOskg3ewV1tszVLy8gVX1u+qFrx6o=
+# True
+```
+
+
+**example/taproot.py**
+
+This example demonstrates how to create a P2TR script with two script spending paths: p2pk and p2ms(2-of-2 multisig).
+
+```sh
+$ python example/taproot.py
+```
+
+**example/transfer.py**
+
+Transfer Bitcoin to another account. Pybtc supports four common types of Bitcoin transactions: P2PKH, P2SH-P2WPKH, P2WPKH, and P2TR. For more complex account types, such as P2SH-P2MS, please refer to [test/test_wallet.py](test/test_wallet.py).
+
+```sh
+$ python example/transfer.py --net develop --prikey 1 --script-type p2pkh --to mg8Jz5776UdyiYcBb9Z873NTozEiADRW5H --value 0.1
+
+# 0x039d1b0fe969d33341a7db9ddd236f632d6851292200603abc5a6c7738bf3079
+```
+
+Before using this script, you first need to execute the code in the Test section. This is because pybtc requires the bitcoin core wallet to provide an account's utxo set.
+
+## Test
+
+The testing of this project relies on regtest. You can set up the regtest node using the following steps:
+
+```sh
+$ wget https://bitcoincore.org/bin/bitcoin-core-27.1/bitcoin-27.1-x86_64-linux-gnu.tar.gz
+$ tar -xvf bitcoin-27.1-x86_64-linux-gnu.tar.gz
+$ cp -R bitcoin-27.1 ~/app/bitcoin # Install to the target location.
+
+$ mkdir ~/.bitcoin
+$ echo "chain=regtest" >> ~/.bitcoin/bitcoin.conf
+$ echo "rpcpassword=pass" >> ~/.bitcoin/bitcoin.conf
+$ echo "rpcuser=user" >> ~/.bitcoin/bitcoin.conf
+$ echo "txindex=1" >> ~/.bitcoin/bitcoin.conf
+
+$ bitcoind
+# Create default wallets
+$ python example/regtest.py
+$ pytest -v
+```
+
+## License
+
+MIT

pabtc-1.2.2/example/addr.py

@@ -0,0 +1,24 @@
+import argparse
+import pabtc
+
+# Calculate the address from a private key.
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--net', type=str, choices=['develop', 'mainnet', 'testnet'], default='develop')
+parser.add_argument('--prikey', type=str, help='private key')
+args = parser.parse_args()
+
+if args.net == 'develop':
+    pabtc.config.current = pabtc.config.develop
+if args.net == 'mainnet':
+    pabtc.config.current = pabtc.config.mainnet
+if args.net == 'testnet':
+    pabtc.config.current = pabtc.config.testnet
+
+prikey = pabtc.core.PriKey(int(args.prikey, 0))
+pubkey = prikey.pubkey()
+
+print('p2pkh      ', pabtc.core.address_p2pkh(pubkey))
+print('p2sh-p2wpkh', pabtc.core.address_p2sh_p2wpkh(pubkey))
+print('p2wpkh     ', pabtc.core.address_p2wpkh(pubkey))
+print('p2tr       ', pabtc.core.address_p2tr(pubkey, bytearray()))

pabtc-1.2.2/example/message.py

@@ -0,0 +1,19 @@
+import argparse
+import pabtc
+
+# Sign a message with the private key and verify it.
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--msg', type=str, help='the message to create a signature of')
+parser.add_argument('--prikey', type=str, help='private key')
+parser.add_argument('--sig', type=str, default='', help='the signature of the message encoded in base 64')
+args = parser.parse_args()
+
+prikey = pabtc.core.PriKey(int(args.prikey, 0))
+pubkey = prikey.pubkey()
+
+if args.sig == '':
+    print(pabtc.core.Message(args.msg).sign(prikey))
+
+if args.sig != '':
+    print(pabtc.core.Message(args.msg).pubkey(args.sig) == pubkey)

pabtc-1.2.2/example/regtest.py

@@ -0,0 +1,29 @@
+import pabtc
+
+pub1 = pabtc.core.PriKey(1).pubkey()
+pub2 = pabtc.core.PriKey(2).pubkey()
+
+pabtc.rpc.call('createwallet', ['main', True, True, None, None, None, True])
+for d in [
+    f'pkh({pub1.sec().hex()})',
+    f'pkh({pub2.sec().hex()})',
+    f'sh(multi(2,{pub1.sec().hex()},{pub2.sec().hex()}))',
+    f'sh(multi(2,{pub2.sec().hex()},{pub1.sec().hex()}))',
+    f'sh(wpkh({pub1.sec().hex()}))',
+    f'sh(wpkh({pub2.sec().hex()}))',
+    f'wpkh({pub1.sec().hex()})',
+    f'wpkh({pub2.sec().hex()})',
+    f'tr({pub1.sec().hex()})',
+    f'tr({pub2.sec().hex()})',
+]:
+    d = pabtc.rpc.get_descriptor_info(d)['descriptor']
+    pabtc.rpc.import_descriptors([{
+        'desc': d,
+        'timestamp': 0,
+    }])
+pabtc.rpc.generate_to_address(10, pabtc.core.address_p2pkh(pub1))
+pabtc.rpc.generate_to_address(10, pabtc.core.address_p2sh_p2ms(2, [pub1, pub2]))
+pabtc.rpc.generate_to_address(10, pabtc.core.address_p2sh_p2wpkh(pub1))
+pabtc.rpc.generate_to_address(10, pabtc.core.address_p2wpkh(pub1))
+pabtc.rpc.generate_to_address(10, pabtc.core.address_p2tr(pub1, bytearray()))
+pabtc.rpc.generate_to_address(99, pabtc.core.address_p2pkh(pub1))

pabtc-1.2.2/example/taproot.py

@@ -0,0 +1,112 @@
+import pabtc
+
+# This example shows how to create a P2TR script with two unlock conditions: p2pk and p2ms.
+
+
+# Here created two scripts, one of which is a p2pk script, which requires that it can only be unlocked by private key 2,
+# and the other is an 2-of-2 multisig script.
+mast = pabtc.core.TapNode(
+    pabtc.core.TapLeaf(pabtc.core.script([
+        pabtc.opcode.op_pushdata(pabtc.core.PriKey(2).pubkey().sec()[1:]),
+        pabtc.opcode.op_checksig,
+    ])),
+    pabtc.core.TapLeaf(pabtc.core.script([
+        pabtc.opcode.op_pushdata(pabtc.core.PriKey(3).pubkey().sec()[1:]),
+        pabtc.opcode.op_checksig,
+        pabtc.opcode.op_pushdata(pabtc.core.PriKey(4).pubkey().sec()[1:]),
+        pabtc.opcode.op_checksigadd,
+        pabtc.opcode.op_n(2),
+        pabtc.opcode.op_equal,
+    ]))
+)
+
+
+class Tp2trp2pk:
+    def __init__(self, pubkey: pabtc.core.PubKey):
+        self.pubkey = pubkey
+        self.addr = pabtc.core.address_p2tr(pubkey, mast.hash)
+        self.script = pabtc.core.script_pubkey_p2tr(self.addr)
+        output_pubkey_byte = bytearray([0x02]) + pabtc.bech32.decode(pabtc.config.current.prefix.bech32, 1, self.addr)
+        output_pubkey = pabtc.core.PubKey.sec_decode(output_pubkey_byte)
+        # Control byte with leaf version and parity bit.
+        if output_pubkey.y & 1:
+            self.prefix = 0xc1
+        else:
+            self.prefix = 0xc0
+
+    def sign(self, tx: pabtc.core.Transaction):
+        for i, e in enumerate(tx.vin):
+            m = tx.digest_segwit_v1(i, pabtc.core.sighash_all, mast.l.script)
+            s = pabtc.core.PriKey(2).sign_schnorr(m) + bytearray([pabtc.core.sighash_all])
+            e.witness[0] = s
+
+    def txin(self, op: pabtc.core.OutPoint):
+        return pabtc.core.TxIn(op, bytearray(), 0xffffffff, [
+            bytearray(65),
+            mast.l.script,
+            bytearray([self.prefix]) + self.pubkey.sec()[1:] + mast.r.hash,
+        ])
+
+
+class Tp2trp2ms:
+    def __init__(self, pubkey: pabtc.core.PubKey):
+        self.pubkey = pubkey
+        self.addr = pabtc.core.address_p2tr(pubkey, mast.hash)
+        self.script = pabtc.core.script_pubkey_p2tr(self.addr)
+        output_pubkey_byte = bytearray([0x02]) + pabtc.bech32.decode(pabtc.config.current.prefix.bech32, 1, self.addr)
+        output_pubkey = pabtc.core.PubKey.sec_decode(output_pubkey_byte)
+        # Control byte with leaf version and parity bit.
+        if output_pubkey.y & 1:
+            self.prefix = 0xc1
+        else:
+            self.prefix = 0xc0
+
+    def sign(self, tx: pabtc.core.Transaction):
+        for i, e in enumerate(tx.vin):
+            m = tx.digest_segwit_v1(i, pabtc.core.sighash_all, mast.r.script)
+            e.witness[0] = pabtc.core.PriKey(4).sign_schnorr(m) + bytearray([pabtc.core.sighash_all])
+            e.witness[1] = pabtc.core.PriKey(3).sign_schnorr(m) + bytearray([pabtc.core.sighash_all])
+
+    def txin(self, op: pabtc.core.OutPoint):
+        return pabtc.core.TxIn(op, bytearray(), 0xffffffff, [
+            bytearray(65),
+            bytearray(65),
+            mast.r.script,
+            bytearray([self.prefix]) + self.pubkey.sec()[1:] + mast.l.hash,
+        ])
+
+
+mate = pabtc.wallet.Wallet(pabtc.wallet.Tp2pkh(1))
+pabtc.rpc.generate_to_address(10, mate.addr)
+
+user_p2tr = pabtc.wallet.Wallet(pabtc.wallet.Tp2tr(1, mast.hash))
+pabtc.rpc.import_descriptors([{
+    'desc': pabtc.rpc.get_descriptor_info(f'addr({user_p2tr.addr})')['descriptor'],
+    'timestamp': 'now',
+}])
+
+# Spending by key path.
+mate.transfer(user_p2tr.script, 1 * pabtc.denomination.bitcoin)
+assert user_p2tr.balance() == pabtc.denomination.bitcoin
+print('main: spending by key path')
+user_p2tr.transfer_all(mate.script)
+assert user_p2tr.balance() == 0
+print('main: spending by key path done')
+
+# Spending by script path: pay to public key.
+mate.transfer(user_p2tr.script, 1 * pabtc.denomination.bitcoin)
+assert user_p2tr.balance() == pabtc.denomination.bitcoin
+user_p2pk = pabtc.wallet.Wallet(Tp2trp2pk(user_p2tr.signer.pubkey))
+print('main: spending by script path p2pk')
+user_p2pk.transfer_all(mate.script)
+assert user_p2tr.balance() == 0
+print('main: spending by script path p2pk done')
+
+# Spending by script path: pay to 2-of-2 multisig script.
+mate.transfer(user_p2tr.script, 1 * pabtc.denomination.bitcoin)
+assert user_p2tr.balance() == pabtc.denomination.bitcoin
+user_p2ms = pabtc.wallet.Wallet(Tp2trp2ms(user_p2tr.signer.pubkey))
+print('main: spending by script path p2ms')
+user_p2ms.transfer_all(mate.script)
+assert user_p2tr.balance() == 0
+print('main: spending by script path p2ms done')

pabtc-1.2.2/example/transfer.py

@@ -0,0 +1,33 @@
+import argparse
+import pabtc
+
+# Transfer bitcoin to another account.
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--net', type=str, choices=['develop', 'mainnet', 'testnet'], default='develop')
+parser.add_argument('--prikey', type=str, help='private key')
+parser.add_argument('--script-type', type=str, choices=['p2pkh', 'p2sh-p2wpkh', 'p2wpkh', 'p2tr'])
+parser.add_argument('--to', type=str, help='bitcoin address')
+parser.add_argument('--value', type=float, help='bitcoin value')
+args = parser.parse_args()
+
+if args.net == 'develop':
+    pabtc.config.current = pabtc.config.develop
+if args.net == 'mainnet':
+    pabtc.config.current = pabtc.config.mainnet
+if args.net == 'testnet':
+    pabtc.config.current = pabtc.config.testnet
+
+accept_script = pabtc.core.script_pubkey(args.to)
+accept_value = int(args.value * pabtc.denomination.bitcoin)
+prikey = int(args.prikey, 0)
+if args.script_type == 'p2pkh':
+    wallet = pabtc.wallet.Wallet(pabtc.wallet.Tp2pkh(prikey))
+if args.script_type == 'p2sh-p2wpkh':
+    wallet = pabtc.wallet.Wallet(pabtc.wallet.Tp2shp2wpkh(prikey))
+if args.script_type == 'p2wpkh':
+    wallet = pabtc.wallet.Wallet(pabtc.wallet.Tp2wpkh(prikey))
+if args.script_type == 'p2tr':
+    wallet = pabtc.wallet.Wallet(pabtc.wallet.Tp2tr(prikey, bytearray()))
+txid = wallet.transfer(accept_script, accept_value)
+print(f'0x{txid.hex()}')

pabtc-1.2.2/pabtc/__init__.py

@@ -0,0 +1,12 @@
+from . import base58
+from . import bech32
+from . import config
+from . import core
+from . import denomination
+from . import ecdsa
+from . import opcode
+from . import ripemd160
+from . import rpc
+from . import schnorr
+from . import secp256k1
+from . import wallet

pabtc-1.2.2/pabtc/base58.py

@@ -0,0 +1,60 @@
+# Copyright (C) 2011 Sam Rushing
+# Copyright (C) 2013-2014 The python-bitcoinlib developers
+#
+# This file is part of python-bitcoinlib.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of python-bitcoinlib, including this file, may be copied, modified,
+# propagated, or distributed except according to the terms contained in the
+# LICENSE file.
+
+# Base58 encoding and decoding
+
+B58_DIGITS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+
+def encode(b: bytearray) -> str:
+    # Encode bytes to a base58-encoded string
+    assert isinstance(b, bytearray)
+    # Convert big-endian bytes to integer
+    n = int.from_bytes(b)
+    # Divide that integer into bas58
+    res = []
+    while n > 0:
+        n, r = divmod(n, 58)
+        res.append(B58_DIGITS[r])
+    res = ''.join(res[::-1])
+    # Encode leading zeros as base58 zeros
+    czero = 0
+    pad = 0
+    for c in b:
+        if c == czero:
+            pad += 1
+        else:
+            break
+    return B58_DIGITS[0] * pad + res
+
+
+def decode(s: str) -> bytearray:
+    # Decode a base58-encoding string, returning bytes.
+    if not s:
+        return bytearray()
+    # Convert the string to an integer
+    n = 0
+    for c in s:
+        n *= 58
+        assert c in B58_DIGITS
+        digit = B58_DIGITS.index(c)
+        n += digit
+    # Convert the integer to bytes
+    res = bytearray(n.to_bytes(max((n.bit_length() + 7) // 8, 1)))
+    # Add padding back.
+    pad = 0
+    for c in s[:-1]:
+        if c == B58_DIGITS[0]:
+            pad += 1
+        else:
+            break
+    return bytearray(pad) + res

pabtc-1.2.2/pabtc/bech32.py

@@ -0,0 +1,150 @@
+# Copyright (c) 2017, 2020 Pieter Wuille
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# BIP-0173 https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+# BIP-0350 https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
+# Derived from https://raw.githubusercontent.com/sipa/bech32/master/ref/python/segwit_addr.py
+#
+# Reference implementation for Bech32/bech32 and segwit addresses.
+
+import typing
+
+CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
+CONST_0 = 1
+CONST_M = 0x2bc830a3
+
+
+def bech32_polymod(data: bytearray) -> int:
+    # Internal function that computes the Bech32 checksum.
+    assert isinstance(data, bytearray)
+    gen = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    chk = 1
+    for val in data:
+        top = chk >> 25
+        chk = chk & 0x1ffffff
+        chk = chk << 5 ^ val
+        for i in range(5):
+            chk ^= gen[i] if ((top >> i) & 1) else 0
+    return chk
+
+
+def bech32_hrpconv(hrp: str) -> bytearray:
+    # Expand the HRP into values for checksum computation.
+    r = bytearray()
+    r.extend([ord(x) >> 5 for x in hrp])
+    r.append(0)
+    r.extend([ord(x) & 31 for x in hrp])
+    return r
+
+
+def bech32_re_arrange_5(data: bytearray) -> bytearray:
+    # Re-arrange those bits into groups of 5, and pad with zeroes at the end if needed.
+    assert isinstance(data, bytearray)
+    acc = 0
+    bit = 0
+    ret = bytearray()
+    max_val = 0x1f
+    max_acc = 0xfff
+    for b in data:
+        acc = ((acc << 8) | b) & max_acc
+        bit += 8
+        for _ in range(bit // 5):
+            bit -= 5
+            ret.append((acc >> bit) & max_val)
+    if bit:
+        pad_bit = 5 - bit
+        ret.append((acc << pad_bit) & max_val)
+    return ret
+
+
+def bech32_create_checksum(hrp: str, ver: int, data: bytearray) -> bytearray:
+    hrpdata = bech32_hrpconv(hrp) + data
+    polymod = bech32_polymod(hrpdata + bytearray(6))
+    if ver == 0:
+        polymod = polymod ^ CONST_0
+    if ver >= 1:
+        polymod = polymod ^ CONST_M
+    return bytearray([(polymod >> 5 * (5 - i)) & 31 for i in range(6)])
+
+
+def bech32_verify_checksum(hrp: str, ver: int, data: bytearray) -> bool:
+    if ver == 0:
+        return bech32_polymod(bech32_hrpconv(hrp) + bytearray(data)) == CONST_0
+    if ver >= 1:
+        return bech32_polymod(bech32_hrpconv(hrp) + bytearray(data)) == CONST_M
+
+
+def bech32_decode(ver: int, bech: str) -> typing.Tuple[str, bytearray]:
+    # Validate a string, and determine HRP and data.
+    assert len(bech) <= 90
+    for c in bech:
+        assert ord(c) >= ord('!')
+        assert ord(c) <= ord('~')
+    bech = bech.lower()
+    pos = bech.rfind('1')
+    assert pos > 0
+    assert pos + 6 < len(bech)
+    for c in bech[pos+1:]:
+        assert c in CHARSET
+    hrp = bech[:pos]
+    data = bytearray([CHARSET.find(x) for x in bech[pos+1:]])
+    assert bech32_verify_checksum(hrp, ver, data)
+    return hrp, data[:-6]
+
+
+def bech32_encode(hrp: str, ver: int, data: bytearray) -> str:
+    datasum = data + bech32_create_checksum(hrp, ver, data)
+    return hrp + '1' + ''.join([CHARSET[d] for d in datasum])
+
+
+def bech32_re_arrange_8(data: bytearray) -> bytearray:
+    # Re-arrange those bits into groups of 8 bits. Any incomplete group at the end MUST be 4 bits or less, MUST be all
+    # zeroes, and is discarded.
+    assert isinstance(data, bytearray)
+    acc = 0
+    bit = 0
+    ret = bytearray()
+    max_val = 0xff
+    max_acc = 0xfff
+    for b in data:
+        assert b <= 0x1f
+        acc = ((acc << 5) | b) & max_acc
+        bit += 5
+        for _ in range(bit // 8):
+            bit -= 8
+            ret.append((acc >> bit) & max_val)
+    assert bit < 5
+    return ret
+
+
+def decode(hrp: str, ver: int, addr: str) -> bytearray:
+    # Decode a segwit address.
+    pre, data = bech32_decode(ver, addr)
+    assert pre == hrp
+    assert ver == data[0]
+    return bech32_re_arrange_8(data[1:])
+
+
+def encode(hrp: str, ver: int, prog: bytearray) -> str:
+    # Encode a segwit address.
+    assert isinstance(prog, bytearray)
+    r = bech32_encode(hrp, ver, bytearray([ver]) + bech32_re_arrange_5(prog))
+    assert prog == decode(hrp, ver, r)
+    return r