gen_key_io_test_vectors Namespace Reference

Functions
def	is_valid (v)
def	is_valid_bech32 (v)
def	gen_valid_base58_vector (template)
def	gen_valid_bech32_vector (template)
def	gen_valid_vectors ()
def	gen_invalid_base58_vector (template)
def	gen_invalid_bech32_vector (template)
def	randbool (p=0.5)
def	gen_invalid_vectors ()

Variables
int	PUBKEY_ADDRESS = 0
int	SCRIPT_ADDRESS = 5
int	PUBKEY_ADDRESS_TEST = 111
int	SCRIPT_ADDRESS_TEST = 196
int	PUBKEY_ADDRESS_REGTEST = 111
int	SCRIPT_ADDRESS_REGTEST = 196
int	PRIVKEY = 128
int	PRIVKEY_TEST = 239
int	PRIVKEY_REGTEST = 239
int	OP_0 = 0x00
int	OP_1 = 0x51
int	OP_2 = 0x52
int	OP_16 = 0x60
int	OP_DUP = 0x76
int	OP_EQUAL = 0x87
int	OP_EQUALVERIFY = 0x88
int	OP_HASH160 = 0xa9
int	OP_CHECKSIG = 0xac
tuple	pubkey_prefix = (OP_DUP, OP_HASH160, 20)
tuple	pubkey_suffix = (OP_EQUALVERIFY, OP_CHECKSIG)
tuple	script_prefix = (OP_HASH160, 20)
tuple	script_suffix = (OP_EQUAL,)
tuple	p2wpkh_prefix = (OP_0, 20)
tuple	p2wsh_prefix = (OP_0, 32)
list	metadata_keys = ['isPrivkey', 'chain', 'isCompressed', 'tryCaseFlip']
list	templates
list	bech32_templates
list	bech32_ng_templates
dictionary	iters = {'valid':gen_valid_vectors, 'invalid':gen_invalid_vectors}
dictionary	uiter = iters[sys.argv[1]]
	count = int(sys.argv[2])
	data = list(islice(uiter(), count))
	stdout
	sort_keys
	True
	indent

Function Documentation

gen_invalid_base58_vector()

def gen_key_io_test_vectors.gen_invalid_base58_vector

(

template

)

Generate possibly invalid vector

gen_invalid_bech32_vector()

def gen_key_io_test_vectors.gen_invalid_bech32_vector

(

template

)

Generate possibly invalid bech32 vector

gen_invalid_vectors()

def gen_key_io_test_vectors.gen_invalid_vectors

(

)

Generate invalid test vectors

gen_valid_base58_vector()

def gen_key_io_test_vectors.gen_valid_base58_vector

(

template

)

Generate valid base58 vector

gen_valid_bech32_vector()

def gen_key_io_test_vectors.gen_valid_bech32_vector

(

template

)

Generate valid bech32 vector

gen_valid_vectors()

def gen_key_io_test_vectors.gen_valid_vectors

(

)

Generate valid test vectors

is_valid()

def gen_key_io_test_vectors.is_valid

(

v

)

Check vector v for validity

is_valid_bech32()

def gen_key_io_test_vectors.is_valid_bech32

(

v

)

Check vector v for bech32 validity

randbool()

def gen_key_io_test_vectors.randbool

(

p = 0.5

)

Return True with P(p)

Variable Documentation

bech32_ng_templates

list gen_key_io_test_vectors.bech32_ng_templates

Initial value:

=  [
  # hrp, version, witprog_size, invalid_bech32, invalid_checksum, invalid_char
  ('tc',    0, 20, False, False, False),
  ('tb',   17, 32, False, False, False),
  ('bcrt',  3,  1, False, False, False),
  ('bc',   15, 41, False, False, False),
  ('tb',    0, 16, False, False, False),
  ('bcrt',  0, 32, True,  False, False),
  ('bc',    0, 16, True,  False, False),
  ('tb',    0, 32, False, True,  False),
  ('bcrt',  0, 20, False, False, True)
]

bech32_templates

list gen_key_io_test_vectors.bech32_templates

Initial value:

=  [
  # hrp, version, witprog_size, metadata, output_prefix
  ('bc',    0, 20, (False, 'main',    None, True), p2wpkh_prefix),
  ('bc',    0, 32, (False, 'main',    None, True), p2wsh_prefix),
  ('bc',    1,  2, (False, 'main',    None, True), (OP_1, 2)),
  ('tb',    0, 20, (False, 'test',    None, True), p2wpkh_prefix),
  ('tb',    0, 32, (False, 'test',    None, True), p2wsh_prefix),
  ('tb',    2, 16, (False, 'test',    None, True), (OP_2, 16)),
  ('bcrt',  0, 20, (False, 'regtest', None, True), p2wpkh_prefix),
  ('bcrt',  0, 32, (False, 'regtest', None, True), p2wsh_prefix),
  ('bcrt', 16, 40, (False, 'regtest', None, True), (OP_16, 40))
]

count

int gen_key_io_test_vectors.count = int(sys.argv[2])

data

gen_key_io_test_vectors.data = list(islice(uiter(), count))

indent

gen_key_io_test_vectors.indent

iters

dictionary gen_key_io_test_vectors.iters = {'valid':gen_valid_vectors, 'invalid':gen_invalid_vectors}

metadata_keys

list gen_key_io_test_vectors.metadata_keys = ['isPrivkey', 'chain', 'isCompressed', 'tryCaseFlip']

OP_0

int gen_key_io_test_vectors.OP_0 = 0x00

OP_1

int gen_key_io_test_vectors.OP_1 = 0x51

OP_16

int gen_key_io_test_vectors.OP_16 = 0x60

OP_2

int gen_key_io_test_vectors.OP_2 = 0x52

OP_CHECKSIG

int gen_key_io_test_vectors.OP_CHECKSIG = 0xac

OP_DUP

int gen_key_io_test_vectors.OP_DUP = 0x76

OP_EQUAL

int gen_key_io_test_vectors.OP_EQUAL = 0x87

OP_EQUALVERIFY

int gen_key_io_test_vectors.OP_EQUALVERIFY = 0x88

OP_HASH160

int gen_key_io_test_vectors.OP_HASH160 = 0xa9

p2wpkh_prefix

tuple gen_key_io_test_vectors.p2wpkh_prefix = (OP_0, 20)

p2wsh_prefix

tuple gen_key_io_test_vectors.p2wsh_prefix = (OP_0, 32)

PRIVKEY

int gen_key_io_test_vectors.PRIVKEY = 128

PRIVKEY_REGTEST

int gen_key_io_test_vectors.PRIVKEY_REGTEST = 239

PRIVKEY_TEST

int gen_key_io_test_vectors.PRIVKEY_TEST = 239

PUBKEY_ADDRESS

int gen_key_io_test_vectors.PUBKEY_ADDRESS = 0

PUBKEY_ADDRESS_REGTEST

int gen_key_io_test_vectors.PUBKEY_ADDRESS_REGTEST = 111

PUBKEY_ADDRESS_TEST

int gen_key_io_test_vectors.PUBKEY_ADDRESS_TEST = 111

pubkey_prefix

tuple gen_key_io_test_vectors.pubkey_prefix = (OP_DUP, OP_HASH160, 20)

pubkey_suffix

tuple gen_key_io_test_vectors.pubkey_suffix = (OP_EQUALVERIFY, OP_CHECKSIG)

SCRIPT_ADDRESS

int gen_key_io_test_vectors.SCRIPT_ADDRESS = 5

SCRIPT_ADDRESS_REGTEST

int gen_key_io_test_vectors.SCRIPT_ADDRESS_REGTEST = 196

SCRIPT_ADDRESS_TEST

int gen_key_io_test_vectors.SCRIPT_ADDRESS_TEST = 196

script_prefix

tuple gen_key_io_test_vectors.script_prefix = (OP_HASH160, 20)

script_suffix

tuple gen_key_io_test_vectors.script_suffix = (OP_EQUAL,)

sort_keys

gen_key_io_test_vectors.sort_keys

stdout

gen_key_io_test_vectors.stdout

templates

list gen_key_io_test_vectors.templates

Initial value:

=  [
  # prefix, payload_size, suffix, metadata, output_prefix, output_suffix
  #                                  None = N/A
  ((PUBKEY_ADDRESS,),         20, (),   (False, 'main',    None,  None), pubkey_prefix, pubkey_suffix),
  ((SCRIPT_ADDRESS,),         20, (),   (False, 'main',    None,  None), script_prefix, script_suffix),
  ((PUBKEY_ADDRESS_TEST,),    20, (),   (False, 'test',    None,  None), pubkey_prefix, pubkey_suffix),
  ((SCRIPT_ADDRESS_TEST,),    20, (),   (False, 'test',    None,  None), script_prefix, script_suffix),
  ((PUBKEY_ADDRESS_REGTEST,), 20, (),   (False, 'regtest', None,  None), pubkey_prefix, pubkey_suffix),
  ((SCRIPT_ADDRESS_REGTEST,), 20, (),   (False, 'regtest', None,  None), script_prefix, script_suffix),
  ((PRIVKEY,),                32, (),   (True,  'main',    False, None), (),            ()),
  ((PRIVKEY,),                32, (1,), (True,  'main',    True,  None), (),            ()),
  ((PRIVKEY_TEST,),           32, (),   (True,  'test',    False, None), (),            ()),
  ((PRIVKEY_TEST,),           32, (1,), (True,  'test',    True,  None), (),            ()),
  ((PRIVKEY_REGTEST,),        32, (),   (True,  'regtest', False, None), (),            ()),
  ((PRIVKEY_REGTEST,),        32, (1,), (True,  'regtest', True,  None), (),            ())
]

True

gen_key_io_test_vectors.True

uiter

def gen_key_io_test_vectors.uiter = iters[sys.argv[1]]