def test_serialize_int32(self): assert serialize_int32(0) == b("00000000") assert serialize_int32(1) == b("01000000") assert serialize_int32(-1) == b("ffffffff") assert serialize_int32(2147483647) == b("ffffff7f") assert serialize_int32(-2147483648) == b("00000080") with self.assertRaises( AssertionError, msg= "should be raised because positive `n` argument is one too high" ): serialize_int32(0x80000000) with self.assertRaises( AssertionError, msg= "should be raised because negative `n` argument is one too low" ): serialize_int32(-0x80000001) with self.assertRaises( AssertionError, msg="should be raised because `n` argument is of the wrong type" ): serialize_int32("wrong type") with self.assertRaises( TypeError, msg="should be raised because all arguments are missing"): serialize_int32()
def test_serialize_int64(self): assert serialize_int64(0) == b("0000000000000000") assert serialize_int64(1) == b("0100000000000000") assert serialize_int64(-1) == b("ffffffffffffffff") assert serialize_int64(9223372036854775807) == b("ffffffffffffff7f") assert serialize_int64(-9223372036854775808) == b("0000000000000080") with self.assertRaises( AssertionError, msg= "should be raised because positive `n` argument is one too high" ): serialize_int64(0x8000000000000000) with self.assertRaises( AssertionError, msg= "should be raised because negative `n` argument is one too low" ): serialize_int64(-0x8000000000000001) with self.assertRaises( AssertionError, msg="should be raised because `n` argument is of the wrong type" ): serialize_int64("wrong type") with self.assertRaises( TypeError, msg="should be raised because all arguments are missing"): serialize_int64()
def test_derive_pubkey(self): privkey: bytes = b("8000000000000000000000000000000000000000000000000000000000000000") pubkey_c_exp: bytes = b("02" "b23790a42be63e1b251ad6c94fdef07271ec0aada31db6c3e8bd32043f8be384") pubkey_u_exp: bytes = b("04" "b23790a42be63e1b251ad6c94fdef07271ec0aada31db6c3e8bd32043f8be384" "fc6b694919d55edbe8d50f88aa81f94517f004f4149ecb58d10a473deb19880e") self.assertEqual(derive_pubkey(privkey), pubkey_c_exp) self.assertEqual(derive_pubkey(privkey, compress=False), pubkey_u_exp)
def test_serialize_pubkey(self): pubkey: tuple[int, int] = ( 93490448322171366308997730228944117434252538148664993621081956959551078425565, 57715698625569537031334996032706854239943749628299835406117911428008835728636 ) pubkey_c_exp: bytes = b("02" "ceb1b7f378a23b765728e7629bbd3283f7289123634994d742b8f4617c3663dd") pubkey_u_exp: bytes = b("04" "ceb1b7f378a23b765728e7629bbd3283f7289123634994d742b8f4617c3663dd" "7f99ed8354f384b39724bd8d81159028e85f5af0e7471023bc94d96a9e72c4fc") self.assertEqual(serialize_pubkey(pubkey), pubkey_c_exp) self.assertEqual(serialize_pubkey(pubkey, compress=False), pubkey_u_exp)
def test_serialize_uint32(self): assert serialize_uint32(0) == b("00000000") assert serialize_uint32(1) == b("01000000") assert serialize_uint32(0xffffffff) == b("ffffffff") assert serialize_uint32(0xfffffffe) == b("feffffff") with self.assertRaises(AssertionError, msg="should be raised because `n` argument is negative"): serialize_uint32(-1) with self.assertRaises(AssertionError, msg="should be raised because `n` argument overflows to more than 32 bits"): serialize_uint32(0x100000000) with self.assertRaises(AssertionError, msg="should be raised because `n` argument is of the wrong type"): serialize_uint32("wrong type") with self.assertRaises(TypeError, msg="should be raised because all arguments are missing"): serialize_uint32()
def input_public_key(): """ Prompt user to input a public key """ while True: try: pubkey = b(input('Public key?')) validate_pubkey(pubkey) return pubkey except AssertionError as ex: print(ex)
def make_p2sh_unlocking_script(redeem_script, scriptsig_script=[]): """ Makes a P2SH (Pay-to-script-hash) unlocking script. """ assert type(redeem_script) in (list, str, bytes) assert type(scriptsig_script) is list if type(redeem_script) is list: redeem_script = compile_script(redeem_script) elif type(redeem_script) is str: redeem_script = b(redeem_script) return scriptsig_script + [redeem_script]
def test_deserialize_int32(self): assert deserialize_int32(b("00000000")) == (0, 4) assert deserialize_int32(b("01000000")) == (1, 4) assert deserialize_int32(b("ffffffff")) == (-1, 4) assert deserialize_int32(b("feffffff")) == (-2, 4) assert deserialize_int32(b("00000000"), 0) == (0, 4) assert deserialize_int32(b("01000000"), 0) == (1, 4) assert deserialize_int32(b("ffffffff"), 0) == (-1, 4) assert deserialize_int32(b("feffffff"), 0) == (-2, 4) assert deserialize_int32(b("00000000cc"), 0) == (0, 4) assert deserialize_int32(b("01000000cc"), 0) == (1, 4) assert deserialize_int32(b("ffffffffcc"), 0) == (-1, 4) assert deserialize_int32(b("feffffffcc"), 0) == (-2, 4) assert deserialize_int32(b("cc00000000"), 1) == (0, 5) assert deserialize_int32(b("cc01000000"), 1) == (1, 5) assert deserialize_int32(b("ccffffffff"), 1) == (-1, 5) assert deserialize_int32(b("ccfeffffff"), 1) == (-2, 5) assert deserialize_int32(b("cc00000000cc"), 1) == (0, 5) assert deserialize_int32(b("cc01000000cc"), 1) == (1, 5) assert deserialize_int32(b("ccffffffffcc"), 1) == (-1, 5) assert deserialize_int32(b("ccfeffffffcc"), 1) == (-2, 5) with self.assertRaises( AssertionError, msg="should be raised because `data` argument is 3 bytes long" ): deserialize_int32(b("000000")) with self.assertRaises( AssertionError, msg= "should be raised because `i` argument is 0 when it should be 1 thus a different " "value is deserialized"): assert deserialize_int32(b("cc00000000"), 0) == 0 with self.assertRaises( AssertionError, msg= "should be raised because `i` argument is 2 when it should be 1 thus there\"s an " "overflow"): deserialize_int32(b("cc00000000"), 2) with self.assertRaises( AssertionError, msg= "should be raised because `data` argument is of the wrong type" ): deserialize_int32("wrong type") with self.assertRaises( TypeError, msg="should be raised because all arguments are missing"): deserialize_int32()
class ScriptOp(object): def __init__(self, opcode, name): self.opcode = opcode self.name = name def __str__(self): return 'OP_' + self.name def __repr__(self): return 'OP_' + self.name # push value OP_0 = ScriptOp(b('00'), '0') OP_FALSE = ScriptOp(b('00'), 'FALSE') OP_PUSHDATA1 = ScriptOp(b('4c'), 'PUSHDATA1') OP_PUSHDATA2 = ScriptOp(b('4d'), 'PUSHDATA2') OP_PUSHDATA4 = ScriptOp(b('4e'), 'PUSHDATA4') OP_1NEGATE = ScriptOp(b('4f'), '1NEGATE') OP_RESERVED = ScriptOp(b('50'), 'RESERVED') OP_1 = ScriptOp(b('51'), '1') OP_TRUE = ScriptOp(b('51'), 'TRUE') OP_2 = ScriptOp(b('52'), '2') OP_3 = ScriptOp(b('53'), '3') OP_4 = ScriptOp(b('54'), '4') OP_5 = ScriptOp(b('55'), '5') OP_6 = ScriptOp(b('56'), '6') OP_7 = ScriptOp(b('57'), '7') OP_8 = ScriptOp(b('58'), '8')
def test_b(self): assert b('') == b'' assert b('00') == b'\x00' assert b('01') == b'\x01' assert b('fe') == b'\xfe' assert b('ff') == b'\xff' assert b('0000') == b'\x00\x00' assert b('0001') == b'\x00\x01' assert b('0100') == b'\x01\x00' assert b('ffff') == b'\xff\xff' assert b('fffe') == b'\xff\xfe' assert b('feff') == b'\xfe\xff' assert b('000000') == b'\x00\x00\x00' assert b('000001') == b'\x00\x00\x01' assert b('010000') == b'\x01\x00\x00' assert b('ffffff') == b'\xff\xff\xff' assert b('fffffe') == b'\xff\xff\xfe' assert b('feffff') == b'\xfe\xff\xff' assert b('42' * 1000) == b'\x42' * 1000 assert b('cC') == b'\xcc' with self.assertRaises(TypeError): b() with self.assertRaises(AssertionError): b(['wrong', 'type'])
from typing import Final from litcoin.secp256k1_ecdsa import secp256k1_ecdsa_sign, secp256k1_ecdsa_verify from litcoin.binhex import b import unittest """ Test cases were generated with the "official" secp256k1 library. https://github.com/bitcoin-core/secp256k1.git Commit hash: 485f608fa9e28f132f127df97136617645effe81 """ MSG_HASH: Final[bytes] = b( "315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3") BAD_MSG_HASH: Final[bytes] = b( "315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd4") # Naturally low s. PRIVKEY_1: Final[ int] = 64232834872967360002211345063887994146790522123274456644695293051595838629937 PUBKEY_1: Final[tuple[int, int]] = ( 55173270408443316925721914421228381042291441320293228708403178145124811593079, 33775624570639333905127850349900297568059235815506565202881330955837833255349 ) EXP_SIG_1: Final[tuple[int, int]] = ( 16586642487822701996776114739632993920426540354541552635482189416136627750540, 30037983404342793357087882969720482313583432727169829015988924382022168147707 ) # Requires modification of s. PRIVKEY_2: Final[ int] = 88524536467685540430760265672189508848005094801200417787118316174097635321572 PUBKEY_2: Final[tuple[int, int]] = (
def test_deserialize_varint(self): assert deserialize_varint(b("00")) == (0, 1) assert deserialize_varint(b("01")) == (1, 1) assert deserialize_varint(b("fb")) == (251, 1) assert deserialize_varint(b("fc")) == (252, 1) assert deserialize_varint(b("fdfd00")) == (253, 3) assert deserialize_varint(b("fdfe00")) == (254, 3) assert deserialize_varint(b("fdff00")) == (255, 3) assert deserialize_varint(b("fd0001")) == (256, 3) assert deserialize_varint(b("fdffff")) == (65535, 3) assert deserialize_varint(b("fe00000100")) == (65536, 5) assert deserialize_varint(b("feffffffff")) == (4294967295, 5) assert deserialize_varint(b("ff0000000001000000")) == (4294967296, 9) assert deserialize_varint( b("ffffffffffffffffff")) == (0xffffffffffffffff, 9) assert deserialize_varint(b("00"), 0) == (0, 1) assert deserialize_varint(b("01"), 0) == (1, 1) assert deserialize_varint(b("fb"), 0) == (251, 1) assert deserialize_varint(b("fc"), 0) == (252, 1) assert deserialize_varint(b("fdfd00"), 0) == (253, 3) assert deserialize_varint(b("fdfe00"), 0) == (254, 3) assert deserialize_varint(b("fdff00"), 0) == (255, 3) assert deserialize_varint(b("fd0001"), 0) == (256, 3) assert deserialize_varint(b("fdffff"), 0) == (65535, 3) assert deserialize_varint(b("fe00000100"), 0) == (65536, 5) assert deserialize_varint(b("feffffffff"), 0) == (4294967295, 5) assert deserialize_varint(b("ff0000000001000000"), 0) == (4294967296, 9) assert deserialize_varint(b("ffffffffffffffffff"), 0) == (0xffffffffffffffff, 9) assert deserialize_varint(b("00cc"), 0) == (0, 1) assert deserialize_varint(b("01cc"), 0) == (1, 1) assert deserialize_varint(b("fbcc"), 0) == (251, 1) assert deserialize_varint(b("fccc"), 0) == (252, 1) assert deserialize_varint(b("fdfd00cc"), 0) == (253, 3) assert deserialize_varint(b("fdfe00cc"), 0) == (254, 3) assert deserialize_varint(b("fdff00cc"), 0) == (255, 3) assert deserialize_varint(b("fd0001cc"), 0) == (256, 3) assert deserialize_varint(b("fdffffcc"), 0) == (65535, 3) assert deserialize_varint(b("fe00000100cc"), 0) == (65536, 5) assert deserialize_varint(b("feffffffffcc"), 0) == (4294967295, 5) assert deserialize_varint(b("ff0000000001000000cc"), 0) == (4294967296, 9) assert deserialize_varint(b("ffffffffffffffffffcc"), 0) == (0xffffffffffffffff, 9) assert deserialize_varint(b("cc00"), 1) == (0, 2) assert deserialize_varint(b("cc01"), 1) == (1, 2) assert deserialize_varint(b("ccfb"), 1) == (251, 2) assert deserialize_varint(b("ccfc"), 1) == (252, 2) assert deserialize_varint(b("ccfdfd00"), 1) == (253, 4) assert deserialize_varint(b("ccfdfe00"), 1) == (254, 4) assert deserialize_varint(b("ccfdff00"), 1) == (255, 4) assert deserialize_varint(b("ccfd0001"), 1) == (256, 4) assert deserialize_varint(b("ccfdffff"), 1) == (65535, 4) assert deserialize_varint(b("ccfe00000100"), 1) == (65536, 6) assert deserialize_varint(b("ccfeffffffff"), 1) == (4294967295, 6) assert deserialize_varint(b("ccff0000000001000000"), 1) == (4294967296, 10) assert deserialize_varint(b("ccffffffffffffffffff"), 1) == (0xffffffffffffffff, 10) assert deserialize_varint(b("cc00cc"), 1) == (0, 2) assert deserialize_varint(b("cc01cc"), 1) == (1, 2) assert deserialize_varint(b("ccfbcc"), 1) == (251, 2) assert deserialize_varint(b("ccfccc"), 1) == (252, 2) assert deserialize_varint(b("ccfdfd00cc"), 1) == (253, 4) assert deserialize_varint(b("ccfdfe00cc"), 1) == (254, 4) assert deserialize_varint(b("ccfdff00cc"), 1) == (255, 4) assert deserialize_varint(b("ccfd0001cc"), 1) == (256, 4) assert deserialize_varint(b("ccfdffffcc"), 1) == (65535, 4) assert deserialize_varint(b("ccfe00000100cc"), 1) == (65536, 6) assert deserialize_varint(b("ccfeffffffffcc"), 1) == (4294967295, 6) assert deserialize_varint(b("ccff0000000001000000cc"), 1) == (4294967296, 10) assert deserialize_varint(b("ccffffffffffffffffffcc"), 1) == (0xffffffffffffffff, 10) with self.assertRaises( AssertionError, msg="should be raised because `i` argument is negative"): deserialize_varint(b("00"), -1) with self.assertRaises( AssertionError, msg="should be raised because `data` argument is 0 bytes long" ): deserialize_varint(b("")) with self.assertRaises( AssertionError, msg="should be raised because `data` argument " "prepended with `fd` but length is 2 instead of 3"): deserialize_varint(b("fdff")) with self.assertRaises( AssertionError, msg="should be raised because `data` argument " "prepended with `fe` but length is 4 instead of 5"): deserialize_varint(b("feffffff")) with self.assertRaises( AssertionError, msg="should be raised because `data` argument " "prepended with `ff` but length is 8 instead of 9"): deserialize_varint(b("ffffffffffffffff")) with self.assertRaises( AssertionError, msg="should be raised because `i` argument is 0 when it " "should be 1 thus a different value is deserialized"): assert deserialize_varint(b("cc00"), 0) == (0, 1) with self.assertRaises( AssertionError, msg="should be raised because `i` argument is 2 when " "it should be 1 thus is out of bounds"): assert deserialize_varint(b("cc00"), 2) == (0, 1) with self.assertRaises( AssertionError, msg= "should be raised because `data` argument is of the wrong type" ): deserialize_varint("wrong type") with self.assertRaises( TypeError, msg="should be raised because all arguments are missing"): deserialize_varint()
from litcoin.mnemonic import entropy_to_wordlist, wordlist_to_entropy, wordlist_to_seed from litcoin.binhex import b import unittest ENTROPY_128 = b("5e2d74684bdf866fe46730a2a4870b59") ENTROPY_160 = b("df78098bac97dfa51908642cbb78fed901716aa8") ENTROPY_192 = b("9876dad7628b980d89c6ba628967cbda67289078651876d9") ENTROPY_224 = b("000837165cbda6829786bd78490273098700091876bcdae789deee80") ENTROPY_256 = b( "000000000476cbbbad72978639890707aaabc098708707d234908fee28760092") WORDLIST_128 = [ "funny", "hill", "borrow", "nut", "wear", "dawn", "muscle", "toward", "pencil", "category", "security", "recall" ] WORDLIST_160 = [ "term", "scare", "glass", "float", "law", "spoon", "goddess", "arrive", "coach", "swift", "distance", "rare", "blade", "relief", "patrol" ] WORDLIST_192 = [ "observe", "replace", "remind", "shallow", "ridge", "almost", "check", "struggle", "glad", "enroll", "very", "regular", "income", "else", "thunder", "perfect", "item", "sniff" ] WORDLIST_224 = [ "abandon", "double", "sheriff", "ride", "surprise", "donor", "fun", "stumble", "joke", "elite", "orphan", "basic", "hybrid", "afraid", "gift", "stuff", "sustain", "detail", "jeans", "tackle", "assume"
def test_deserialize_uint64(self): assert deserialize_uint64(b("0000000000000000")) == (0, 8) assert deserialize_uint64(b("0100000000000000")) == (1, 8) assert deserialize_uint64(b("ffffffffffffffff")) == (0xffffffffffffffff, 8) assert deserialize_uint64(b("feffffffffffffff")) == (0xfffffffffffffffe, 8) assert deserialize_uint64(b("0000000000000000"), 0) == (0, 8) assert deserialize_uint64(b("0100000000000000"), 0) == (1, 8) assert deserialize_uint64(b("ffffffffffffffff"), 0) == (0xffffffffffffffff, 8) assert deserialize_uint64(b("feffffffffffffff"), 0) == (0xfffffffffffffffe, 8) assert deserialize_uint64(b("0000000000000000cc"), 0) == (0, 8) assert deserialize_uint64(b("0100000000000000cc"), 0) == (1, 8) assert deserialize_uint64(b("ffffffffffffffffcc"), 0) == (0xffffffffffffffff, 8) assert deserialize_uint64(b("feffffffffffffffcc"), 0) == (0xfffffffffffffffe, 8) assert deserialize_uint64(b("cc0000000000000000"), 1) == (0, 9) assert deserialize_uint64(b("cc0100000000000000"), 1) == (1, 9) assert deserialize_uint64(b("ccffffffffffffffff"), 1) == (0xffffffffffffffff, 9) assert deserialize_uint64(b("ccfeffffffffffffff"), 1) == (0xfffffffffffffffe, 9) assert deserialize_uint64(b("cc0000000000000000cc"), 1) == (0, 9) assert deserialize_uint64(b("cc0100000000000000cc"), 1) == (1, 9) assert deserialize_uint64(b("ccffffffffffffffffcc"), 1) == (0xffffffffffffffff, 9) assert deserialize_uint64(b("ccfeffffffffffffffcc"), 1) == (0xfffffffffffffffe, 9) with self.assertRaises(AssertionError, msg="should be raised because `i` argument is negative"): deserialize_uint64(b("0000000000000000"), -1) with self.assertRaises(AssertionError, msg="should be raised because `data` argument is 7 bytes long"): deserialize_uint64(b("00000000000000")) with self.assertRaises(AssertionError, msg="should be raised because `i` argument is 0 when it should be 1 thus a different " "value is deserialized"): assert deserialize_uint64(b("cc0000000000000000"), 0) == 0 with self.assertRaises(AssertionError, msg="should be raised because `i` argument is 2 when it should be 1 thus there\"s an " "overflow"): deserialize_uint64(b("cc0000000000000000"), 2) with self.assertRaises(AssertionError, msg="should be raised because `data` argument is of the wrong type"): deserialize_uint64("wrong type") with self.assertRaises(TypeError, msg="should be raised because all arguments are missing"): deserialize_uint64()