def test_is_zero(self):
"""
test_is_zero ensures that checking if a field is zero works as expected.
"""
f = field.FieldVal()
assert f.isZero()
f.setInt(1)
assert not f.isZero()
f.zero()
assert f.isZero()
def test_set_int(self):
"""
test_set_int ensures that setting a field value to various native
integers works as expected.
"""
tests = [
(1, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 1
(5, [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 5
(65535, [65535, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 2^16 - 1
(67108864, [67108864, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 2^26
(67108865, [67108865, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 2^26 + 1
(4294967295, [4294967295, 0, 0, 0, 0, 0, 0, 0, 0, 0]), # 2^32 - 1
]
for i, v in tests:
f = field.FieldVal()
f.setInt(i)
assert v == f.n
def test_normalize(self, benchmark):
f = field.FieldVal()
f.n = [0xFFFFFFFF, 0xFFFFFFC0, 0xFC0, 0, 0, 0, 0, 0, 0, 0]
benchmark(f.normalize)
def test_normalize(self):
"""
test_normalize ensures that normalizing the internal field words works
as expected.
"""
tests = [
# 5
[ # 0
[0x00000005, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0x00000005, 0, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^26
[ # 1
[0x04000000, 0x0, 0, 0, 0, 0, 0, 0, 0, 0],
[0x00000000, 0x1, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^26 + 1
[ # 2
[0x04000001, 0x0, 0, 0, 0, 0, 0, 0, 0, 0],
[0x00000001, 0x1, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^32 - 1
[ # 3
[0xFFFFFFFF, 0x00, 0, 0, 0, 0, 0, 0, 0, 0],
[0x03FFFFFF, 0x3F, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^32
[ # 4
[0x04000000, 0x3F, 0, 0, 0, 0, 0, 0, 0, 0],
[0x00000000, 0x40, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^32 + 1
[ # 5
[0x04000001, 0x3F, 0, 0, 0, 0, 0, 0, 0, 0],
[0x00000001, 0x40, 0, 0, 0, 0, 0, 0, 0, 0],
],
# 2^64 - 1
[ # 6
[0xFFFFFFFF, 0xFFFFFFC0, 0xFC0, 0, 0, 0, 0, 0, 0, 0],
[0x03FFFFFF, 0x03FFFFFF, 0xFFF, 0, 0, 0, 0, 0, 0, 0],
],
# 2^64
[ # 7
[0x04000000, 0x03FFFFFF, 0x0FFF, 0, 0, 0, 0, 0, 0, 0],
[0x00000000, 0x00000000, 0x1000, 0, 0, 0, 0, 0, 0, 0],
],
# 2^64 + 1
[ # 8
[0x04000001, 0x03FFFFFF, 0x0FFF, 0, 0, 0, 0, 0, 0, 0],
[0x00000001, 0x00000000, 0x1000, 0, 0, 0, 0, 0, 0, 0],
],
# 2^96 - 1
[ # 9
[
0xFFFFFFFF, 0xFFFFFFC0, 0xFFFFFFC0, 0x3FFC0, 0, 0, 0, 0, 0,
0
],
[
0x03FFFFFF, 0x03FFFFFF, 0x03FFFFFF, 0x3FFFF, 0, 0, 0, 0, 0,
0
],
],
# 2^96
[ # 10
[
0x04000000, 0x03FFFFFF, 0x03FFFFFF, 0x3FFFF, 0, 0, 0, 0, 0,
0
],
[
0x00000000, 0x00000000, 0x00000000, 0x40000, 0, 0, 0, 0, 0,
0
],
],
# 2^128 - 1
[ # 11
[
0xFFFFFFFF,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFC0,
0,
0,
0,
0,
0,
],
[
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0xFFFFFF,
0,
0,
0,
0,
0,
],
],
# 2^128
[ # 12
[
0x04000000,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x0FFFFFF,
0,
0,
0,
0,
0,
],
[
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x1000000,
0,
0,
0,
0,
0,
],
],
# 2^256 - 4294968273 (secp256k1 prime)
[ # 13
[
0xFFFFFC2F,
0xFFFFFF80,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0x3FFFC0,
],
[
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x000000,
],
],
# Prime larger than P where both first and second words are larger
# than P's first and second words.
[ # 14
[
0xFFFFFC30,
0xFFFFFF86,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0x3FFFC0,
],
[
0x00000001,
0x00000006,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x000000,
],
],
# Prime larger than P where only the second word is larger
# than P's second words.
[ # 15
[
0xFFFFFC2A,
0xFFFFFF87,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0x3FFFC0,
],
[
0x03FFFFFB,
0x00000006,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x000000,
],
],
# 2^256 - 1
[ # 16
[
0xFFFFFFFF,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0xFFFFFFC0,
0x3FFFC0,
],
[
0x000003D0,
0x00000040,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x000000,
],
],
# Prime with field representation such that the initial
# reduction does not result in a carry to bit 256.
#
# 2^256 - 4294968273 (secp256k1 prime)
[ # 17
[
0x03FFFC2F,
0x03FFFFBF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x003FFFFF,
],
[
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to its first
# word and does not result in a carry to bit 256.
#
# 2^256 - 4294968272 (secp256k1 prime + 1)
[ # 18
[
0x03FFFC30,
0x03FFFFBF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x003FFFFF,
],
[
0x00000001,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to its second
# word and does not result in a carry to bit 256.
#
# 2^256 - 4227859409 (secp256k1 prime + 0x4000000)
[ # 19
[
0x03FFFC2F,
0x03FFFFC0,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x003FFFFF,
],
[
0x00000000,
0x00000001,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to a carry to
# bit 256, but would not be without the carry. These values
# come from the fact that P is 2^256 - 4294968273 and 977 is
# the low order word in the internal field representation.
#
# 2^256 * 5 - ((4294968273 - (977+1)) * 4)
[ # 20
[
0x03FFFFFF,
0x03FFFEFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x0013FFFFF,
],
[
0x00001314,
0x00000040,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x000000000,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to both a
# carry to bit 256 and the first word.
[ # 21
[
0x03FFFC30,
0x03FFFFBF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x07FFFFFF,
0x003FFFFF,
],
[
0x00000001,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000001,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to both a
# carry to bit 256 and the second word.
#
[ # 22
[
0x03FFFC2F,
0x03FFFFC0,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x3FFFFFF,
0x07FFFFFF,
0x003FFFFF,
],
[
0x00000000,
0x00000001,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x0000000,
0x00000000,
0x00000001,
],
],
# Prime larger than P that reduces to a value which is still
# larger than P when it has a magnitude of 1 due to a carry to
# bit 256 and the first and second words.
#
[ # 23
[
0x03FFFC30,
0x03FFFFC0,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x03FFFFFF,
0x07FFFFFF,
0x003FFFFF,
],
[
0x00000001,
0x00000001,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000001,
],
],
]
for i, (raw, normalized) in enumerate(tests):
f = field.FieldVal()
f.n = raw
f.normalize()
assert normalized == f.n, f"test {i}"