Browse Source
0.168213838[Qt] tolerate BIP173/bech32 addresses during input validation (Jonas Schnelli)06eaca6[RPC] Wallet: test importing of native witness scripts (NicolasDorier)fd0041aUse BIP173 addresses in segwit.py test (Pieter Wuille)e278f12Support BIP173 in addwitnessaddress (Pieter Wuille)c091b99Implement BIP173 addresses and tests (Pieter Wuille)bd355b8Add regtest testing to base58_tests (Pieter Wuille)6565c55Convert base58_tests from type/payload to scriptPubKey comparison (Pieter Wuille)8fd2267Import Bech32 C++ reference code & tests (Pieter Wuille)1e46ebdImplement {Encode,Decode}Destination without CBitcoinAddress (Pieter Wuille) Pull request description: Builds on top of #11117. This adds support for: * Creating BIP173 addresses for testing (through `addwitnessaddress`, though by default it still produces P2SH versions) * Sending to BIP173 addresses (including non-v0 ones) * Analysing BIP173 addresses (through `validateaddress`) It includes a reformatted version of the [C++ Bech32 reference code](https://github.com/sipa/bech32/tree/master/ref/c%2B%2B) and an independent implementation of the address encoding/decoding logic (integrated with CTxDestination). All BIP173 test vectors are included. Not included (and intended for other PRs): * Full wallet support for SegWit (which would include automatically adding witness scripts to the wallet during automatic keypool topup, SegWit change outputs, ...) [see #11403] * Splitting base58.cpp and tests/base58_tests.cpp up into base58-specific code, and "address encoding"-code [see #11372] * Error locating in UI for BIP173 addresses. Tree-SHA512: 238031185fd07f3ac873c586043970cc2db91bf7735c3c168cb33a3db39a7bda81d4891b649685bb17ef90dc63af0328e7705d8cd3e8dafd6c4d3c08fb230341
Wladimir J. van der Laan
7 years ago
30 changed files with 1290 additions and 531 deletions
@ -0,0 +1,191 @@ |
|||||||
|
// Copyright (c) 2017 Pieter Wuille
|
||||||
|
// Distributed under the MIT software license, see the accompanying
|
||||||
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||||
|
|
||||||
|
#include "bech32.h" |
||||||
|
|
||||||
|
namespace |
||||||
|
{ |
||||||
|
|
||||||
|
typedef std::vector<uint8_t> data; |
||||||
|
|
||||||
|
/** The Bech32 character set for encoding. */ |
||||||
|
const char* CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"; |
||||||
|
|
||||||
|
/** The Bech32 character set for decoding. */ |
||||||
|
const int8_t CHARSET_REV[128] = { |
||||||
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
||||||
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
||||||
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
||||||
|
15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1, |
||||||
|
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, |
||||||
|
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1, |
||||||
|
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, |
||||||
|
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1 |
||||||
|
}; |
||||||
|
|
||||||
|
/** Concatenate two byte arrays. */ |
||||||
|
data Cat(data x, const data& y) |
||||||
|
{ |
||||||
|
x.insert(x.end(), y.begin(), y.end()); |
||||||
|
return x; |
||||||
|
} |
||||||
|
|
||||||
|
/** This function will compute what 6 5-bit values to XOR into the last 6 input values, in order to
|
||||||
|
* make the checksum 0. These 6 values are packed together in a single 30-bit integer. The higher |
||||||
|
* bits correspond to earlier values. */ |
||||||
|
uint32_t PolyMod(const data& v) |
||||||
|
{ |
||||||
|
// The input is interpreted as a list of coefficients of a polynomial over F = GF(32), with an
|
||||||
|
// implicit 1 in front. If the input is [v0,v1,v2,v3,v4], that polynomial is v(x) =
|
||||||
|
// 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4. The implicit 1 guarantees that
|
||||||
|
// [v0,v1,v2,...] has a distinct checksum from [0,v0,v1,v2,...].
|
||||||
|
|
||||||
|
// The output is a 30-bit integer whose 5-bit groups are the coefficients of the remainder of
|
||||||
|
// v(x) mod g(x), where g(x) is the Bech32 generator,
|
||||||
|
// x^6 + {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}. g(x) is chosen in such a way
|
||||||
|
// that the resulting code is a BCH code, guaranteeing detection of up to 3 errors within a
|
||||||
|
// window of 1023 characters. Among the various possible BCH codes, one was selected to in
|
||||||
|
// fact guarantee detection of up to 4 errors within a window of 89 characters.
|
||||||
|
|
||||||
|
// Note that the coefficients are elements of GF(32), here represented as decimal numbers
|
||||||
|
// between {}. In this finite field, addition is just XOR of the corresponding numbers. For
|
||||||
|
// example, {27} + {13} = {27 ^ 13} = {22}. Multiplication is more complicated, and requires
|
||||||
|
// treating the bits of values themselves as coefficients of a polynomial over a smaller field,
|
||||||
|
// GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example, {5} * {26} =
|
||||||
|
// (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 + a^3 + a) = a^6 + a^5 + a^4 + a
|
||||||
|
// = a^3 + 1 (mod a^5 + a^3 + 1) = {9}.
|
||||||
|
|
||||||
|
// During the course of the loop below, `c` contains the bitpacked coefficients of the
|
||||||
|
// polynomial constructed from just the values of v that were processed so far, mod g(x). In
|
||||||
|
// the above example, `c` initially corresponds to 1 mod (x), and after processing 2 inputs of
|
||||||
|
// v, it corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the starting value
|
||||||
|
// for `c`.
|
||||||
|
uint32_t c = 1; |
||||||
|
for (auto v_i : v) { |
||||||
|
// We want to update `c` to correspond to a polynomial with one extra term. If the initial
|
||||||
|
// value of `c` consists of the coefficients of c(x) = f(x) mod g(x), we modify it to
|
||||||
|
// correspond to c'(x) = (f(x) * x + v_i) mod g(x), where v_i is the next input to
|
||||||
|
// process. Simplifying:
|
||||||
|
// c'(x) = (f(x) * x + v_i) mod g(x)
|
||||||
|
// ((f(x) mod g(x)) * x + v_i) mod g(x)
|
||||||
|
// (c(x) * x + v_i) mod g(x)
|
||||||
|
// If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to compute
|
||||||
|
// c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + v_i mod g(x)
|
||||||
|
// = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i mod g(x)
|
||||||
|
// = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i
|
||||||
|
// If we call (x^6 mod g(x)) = k(x), this can be written as
|
||||||
|
// c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i) + c0*k(x)
|
||||||
|
|
||||||
|
// First, determine the value of c0:
|
||||||
|
uint8_t c0 = c >> 25; |
||||||
|
|
||||||
|
// Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i:
|
||||||
|
c = ((c & 0x1ffffff) << 5) ^ v_i; |
||||||
|
|
||||||
|
// Finally, for each set bit n in c0, conditionally add {2^n}k(x):
|
||||||
|
if (c0 & 1) c ^= 0x3b6a57b2; // k(x) = {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}
|
||||||
|
if (c0 & 2) c ^= 0x26508e6d; // {2}k(x) = {19}x^5 + {5}x^4 + x^3 + {3}x^2 + {19}x + {13}
|
||||||
|
if (c0 & 4) c ^= 0x1ea119fa; // {4}k(x) = {15}x^5 + {10}x^4 + {2}x^3 + {6}x^2 + {15}x + {26}
|
||||||
|
if (c0 & 8) c ^= 0x3d4233dd; // {8}k(x) = {30}x^5 + {20}x^4 + {4}x^3 + {12}x^2 + {30}x + {29}
|
||||||
|
if (c0 & 16) c ^= 0x2a1462b3; // {16}k(x) = {21}x^5 + x^4 + {8}x^3 + {24}x^2 + {21}x + {19}
|
||||||
|
} |
||||||
|
return c; |
||||||
|
} |
||||||
|
|
||||||
|
/** Convert to lower case. */ |
||||||
|
inline unsigned char LowerCase(unsigned char c) |
||||||
|
{ |
||||||
|
return (c >= 'A' && c <= 'Z') ? (c - 'A') + 'a' : c; |
||||||
|
} |
||||||
|
|
||||||
|
/** Expand a HRP for use in checksum computation. */ |
||||||
|
data ExpandHRP(const std::string& hrp) |
||||||
|
{ |
||||||
|
data ret; |
||||||
|
ret.reserve(hrp.size() + 90); |
||||||
|
ret.resize(hrp.size() * 2 + 1); |
||||||
|
for (size_t i = 0; i < hrp.size(); ++i) { |
||||||
|
unsigned char c = hrp[i]; |
||||||
|
ret[i] = c >> 5; |
||||||
|
ret[i + hrp.size() + 1] = c & 0x1f; |
||||||
|
} |
||||||
|
ret[hrp.size()] = 0; |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
/** Verify a checksum. */ |
||||||
|
bool VerifyChecksum(const std::string& hrp, const data& values) |
||||||
|
{ |
||||||
|
// PolyMod computes what value to xor into the final values to make the checksum 0. However,
|
||||||
|
// if we required that the checksum was 0, it would be the case that appending a 0 to a valid
|
||||||
|
// list of values would result in a new valid list. For that reason, Bech32 requires the
|
||||||
|
// resulting checksum to be 1 instead.
|
||||||
|
return PolyMod(Cat(ExpandHRP(hrp), values)) == 1; |
||||||
|
} |
||||||
|
|
||||||
|
/** Create a checksum. */ |
||||||
|
data CreateChecksum(const std::string& hrp, const data& values) |
||||||
|
{ |
||||||
|
data enc = Cat(ExpandHRP(hrp), values); |
||||||
|
enc.resize(enc.size() + 6); // Append 6 zeroes
|
||||||
|
uint32_t mod = PolyMod(enc) ^ 1; // Determine what to XOR into those 6 zeroes.
|
||||||
|
data ret(6); |
||||||
|
for (size_t i = 0; i < 6; ++i) { |
||||||
|
// Convert the 5-bit groups in mod to checksum values.
|
||||||
|
ret[i] = (mod >> (5 * (5 - i))) & 31; |
||||||
|
} |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
namespace bech32 |
||||||
|
{ |
||||||
|
|
||||||
|
/** Encode a Bech32 string. */ |
||||||
|
std::string Encode(const std::string& hrp, const data& values) { |
||||||
|
data checksum = CreateChecksum(hrp, values); |
||||||
|
data combined = Cat(values, checksum); |
||||||
|
std::string ret = hrp + '1'; |
||||||
|
ret.reserve(ret.size() + combined.size()); |
||||||
|
for (auto c : combined) { |
||||||
|
ret += CHARSET[c]; |
||||||
|
} |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
/** Decode a Bech32 string. */ |
||||||
|
std::pair<std::string, data> Decode(const std::string& str) { |
||||||
|
bool lower = false, upper = false; |
||||||
|
for (size_t i = 0; i < str.size(); ++i) { |
||||||
|
unsigned char c = str[i]; |
||||||
|
if (c < 33 || c > 126) return {}; |
||||||
|
if (c >= 'a' && c <= 'z') lower = true; |
||||||
|
if (c >= 'A' && c <= 'Z') upper = true; |
||||||
|
} |
||||||
|
if (lower && upper) return {}; |
||||||
|
size_t pos = str.rfind('1'); |
||||||
|
if (str.size() > 90 || pos == str.npos || pos == 0 || pos + 7 > str.size()) { |
||||||
|
return {}; |
||||||
|
} |
||||||
|
data values(str.size() - 1 - pos); |
||||||
|
for (size_t i = 0; i < str.size() - 1 - pos; ++i) { |
||||||
|
unsigned char c = str[i + pos + 1]; |
||||||
|
int8_t rev = (c < 33 || c > 126) ? -1 : CHARSET_REV[c]; |
||||||
|
if (rev == -1) { |
||||||
|
return {}; |
||||||
|
} |
||||||
|
values[i] = rev; |
||||||
|
} |
||||||
|
std::string hrp; |
||||||
|
for (size_t i = 0; i < pos; ++i) { |
||||||
|
hrp += LowerCase(str[i]); |
||||||
|
} |
||||||
|
if (!VerifyChecksum(hrp, values)) { |
||||||
|
return {}; |
||||||
|
} |
||||||
|
return {hrp, data(values.begin(), values.end() - 6)}; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace bech32
|
||||||
@ -0,0 +1,25 @@ |
|||||||
|
// Copyright (c) 2017 Pieter Wuille
|
||||||
|
// Distributed under the MIT software license, see the accompanying
|
||||||
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||||
|
|
||||||
|
// Bech32 is a string encoding format used in newer address types.
|
||||||
|
// The output consists of a human-readable part (alphanumeric), a
|
||||||
|
// separator character (1), and a base32 data section, the last
|
||||||
|
// 6 characters of which are a checksum.
|
||||||
|
//
|
||||||
|
// For more information, see BIP 173.
|
||||||
|
|
||||||
|
#include <stdint.h> |
||||||
|
#include <string> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
namespace bech32 |
||||||
|
{ |
||||||
|
|
||||||
|
/** Encode a Bech32 string. Returns the empty string in case of failure. */ |
||||||
|
std::string Encode(const std::string& hrp, const std::vector<uint8_t>& values); |
||||||
|
|
||||||
|
/** Decode a Bech32 string. Returns (hrp, data). Empty hrp means failure. */ |
||||||
|
std::pair<std::string, std::vector<uint8_t>> Decode(const std::string& str); |
||||||
|
|
||||||
|
} // namespace bech32
|
||||||
@ -0,0 +1,67 @@ |
|||||||
|
// Copyright (c) 2017 Pieter Wuille
|
||||||
|
// Distributed under the MIT software license, see the accompanying
|
||||||
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||||
|
|
||||||
|
#include "bech32.h" |
||||||
|
#include "test/test_bitcoin.h" |
||||||
|
|
||||||
|
#include <boost/test/unit_test.hpp> |
||||||
|
|
||||||
|
BOOST_FIXTURE_TEST_SUITE(bech32_tests, BasicTestingSetup) |
||||||
|
|
||||||
|
bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2) |
||||||
|
{ |
||||||
|
if (s1.size() != s2.size()) return false; |
||||||
|
for (size_t i = 0; i < s1.size(); ++i) { |
||||||
|
char c1 = s1[i]; |
||||||
|
if (c1 >= 'A' && c1 <= 'Z') c1 -= ('A' - 'a'); |
||||||
|
char c2 = s2[i]; |
||||||
|
if (c2 >= 'A' && c2 <= 'Z') c2 -= ('A' - 'a'); |
||||||
|
if (c1 != c2) return false; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
BOOST_AUTO_TEST_CASE(bip173_testvectors_valid) |
||||||
|
{ |
||||||
|
static const std::string CASES[] = { |
||||||
|
"A12UEL5L", |
||||||
|
"a12uel5l", |
||||||
|
"an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1tt5tgs", |
||||||
|
"abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw", |
||||||
|
"11qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqc8247j", |
||||||
|
"split1checkupstagehandshakeupstreamerranterredcaperred2y9e3w", |
||||||
|
"?1ezyfcl", |
||||||
|
}; |
||||||
|
for (const std::string& str : CASES) { |
||||||
|
auto ret = bech32::Decode(str); |
||||||
|
BOOST_CHECK(!ret.first.empty()); |
||||||
|
std::string recode = bech32::Encode(ret.first, ret.second); |
||||||
|
BOOST_CHECK(!recode.empty()); |
||||||
|
BOOST_CHECK(CaseInsensitiveEqual(str, recode)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
BOOST_AUTO_TEST_CASE(bip173_testvectors_invalid) |
||||||
|
{ |
||||||
|
static const std::string CASES[] = { |
||||||
|
" 1nwldj5", |
||||||
|
"\x7f""1axkwrx", |
||||||
|
"\x80""1eym55h", |
||||||
|
"an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx", |
||||||
|
"pzry9x0s0muk", |
||||||
|
"1pzry9x0s0muk", |
||||||
|
"x1b4n0q5v", |
||||||
|
"li1dgmt3", |
||||||
|
"de1lg7wt\xff", |
||||||
|
"A1G7SGD8", |
||||||
|
"10a06t8", |
||||||
|
"1qzzfhee", |
||||||
|
}; |
||||||
|
for (const std::string& str : CASES) { |
||||||
|
auto ret = bech32::Decode(str); |
||||||
|
BOOST_CHECK(ret.first.empty()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
BOOST_AUTO_TEST_SUITE_END() |
||||||
@ -0,0 +1,107 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# Copyright (c) 2017 Pieter Wuille |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
"""Reference implementation for Bech32 and segwit addresses.""" |
||||||
|
|
||||||
|
|
||||||
|
CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l" |
||||||
|
|
||||||
|
|
||||||
|
def bech32_polymod(values): |
||||||
|
"""Internal function that computes the Bech32 checksum.""" |
||||||
|
generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3] |
||||||
|
chk = 1 |
||||||
|
for value in values: |
||||||
|
top = chk >> 25 |
||||||
|
chk = (chk & 0x1ffffff) << 5 ^ value |
||||||
|
for i in range(5): |
||||||
|
chk ^= generator[i] if ((top >> i) & 1) else 0 |
||||||
|
return chk |
||||||
|
|
||||||
|
|
||||||
|
def bech32_hrp_expand(hrp): |
||||||
|
"""Expand the HRP into values for checksum computation.""" |
||||||
|
return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp] |
||||||
|
|
||||||
|
|
||||||
|
def bech32_verify_checksum(hrp, data): |
||||||
|
"""Verify a checksum given HRP and converted data characters.""" |
||||||
|
return bech32_polymod(bech32_hrp_expand(hrp) + data) == 1 |
||||||
|
|
||||||
|
|
||||||
|
def bech32_create_checksum(hrp, data): |
||||||
|
"""Compute the checksum values given HRP and data.""" |
||||||
|
values = bech32_hrp_expand(hrp) + data |
||||||
|
polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ 1 |
||||||
|
return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)] |
||||||
|
|
||||||
|
|
||||||
|
def bech32_encode(hrp, data): |
||||||
|
"""Compute a Bech32 string given HRP and data values.""" |
||||||
|
combined = data + bech32_create_checksum(hrp, data) |
||||||
|
return hrp + '1' + ''.join([CHARSET[d] for d in combined]) |
||||||
|
|
||||||
|
|
||||||
|
def bech32_decode(bech): |
||||||
|
"""Validate a Bech32 string, and determine HRP and data.""" |
||||||
|
if ((any(ord(x) < 33 or ord(x) > 126 for x in bech)) or |
||||||
|
(bech.lower() != bech and bech.upper() != bech)): |
||||||
|
return (None, None) |
||||||
|
bech = bech.lower() |
||||||
|
pos = bech.rfind('1') |
||||||
|
if pos < 1 or pos + 7 > len(bech) or len(bech) > 90: |
||||||
|
return (None, None) |
||||||
|
if not all(x in CHARSET for x in bech[pos+1:]): |
||||||
|
return (None, None) |
||||||
|
hrp = bech[:pos] |
||||||
|
data = [CHARSET.find(x) for x in bech[pos+1:]] |
||||||
|
if not bech32_verify_checksum(hrp, data): |
||||||
|
return (None, None) |
||||||
|
return (hrp, data[:-6]) |
||||||
|
|
||||||
|
|
||||||
|
def convertbits(data, frombits, tobits, pad=True): |
||||||
|
"""General power-of-2 base conversion.""" |
||||||
|
acc = 0 |
||||||
|
bits = 0 |
||||||
|
ret = [] |
||||||
|
maxv = (1 << tobits) - 1 |
||||||
|
max_acc = (1 << (frombits + tobits - 1)) - 1 |
||||||
|
for value in data: |
||||||
|
if value < 0 or (value >> frombits): |
||||||
|
return None |
||||||
|
acc = ((acc << frombits) | value) & max_acc |
||||||
|
bits += frombits |
||||||
|
while bits >= tobits: |
||||||
|
bits -= tobits |
||||||
|
ret.append((acc >> bits) & maxv) |
||||||
|
if pad: |
||||||
|
if bits: |
||||||
|
ret.append((acc << (tobits - bits)) & maxv) |
||||||
|
elif bits >= frombits or ((acc << (tobits - bits)) & maxv): |
||||||
|
return None |
||||||
|
return ret |
||||||
|
|
||||||
|
|
||||||
|
def decode(hrp, addr): |
||||||
|
"""Decode a segwit address.""" |
||||||
|
hrpgot, data = bech32_decode(addr) |
||||||
|
if hrpgot != hrp: |
||||||
|
return (None, None) |
||||||
|
decoded = convertbits(data[1:], 5, 8, False) |
||||||
|
if decoded is None or len(decoded) < 2 or len(decoded) > 40: |
||||||
|
return (None, None) |
||||||
|
if data[0] > 16: |
||||||
|
return (None, None) |
||||||
|
if data[0] == 0 and len(decoded) != 20 and len(decoded) != 32: |
||||||
|
return (None, None) |
||||||
|
return (data[0], decoded) |
||||||
|
|
||||||
|
|
||||||
|
def encode(hrp, witver, witprog): |
||||||
|
"""Encode a segwit address.""" |
||||||
|
ret = bech32_encode(hrp, [witver] + convertbits(witprog, 8, 5)) |
||||||
|
if decode(hrp, ret) == (None, None): |
||||||
|
return None |
||||||
|
return ret |
||||||
Loading…
Reference in new issue