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()
