def test_verify_scenario_2():
context = scryptlib.utils.create_dummy_input_context()
context.utxo.script_pubkey = escrow.locking_script
context.utxo.value = input_sats
change_out = TxOutput(int(input_sats - fee),
P2PKH_Address(pkh_A, Bitcoin).to_script())
context.tx.outputs.append(change_out)
sighash_flag = SigHash(SigHash.ALL | SigHash.FORKID)
sighash = context.tx.signature_hash(0, input_sats, escrow.locking_script,
sighash_flag)
sig_A = key_priv_A.sign(sighash, hasher=None)
sig_A = sig_A + pack_byte(sighash_flag)
sig_E = key_priv_E.sign(sighash, hasher=None)
sig_E = sig_E + pack_byte(sighash_flag)
preimage = scryptlib.utils.get_preimage_from_input_context(
context, sighash_flag)
verify_result = escrow.unlock(SigHashPreimage(preimage), PubKey(key_pub_A),
Sig(sig_A), PubKey(key_pub_E), Sig(sig_E),
Bytes(secret0)).verify(context)
assert verify_result == True
# Wrong secret
with pytest.raises(bitcoinx.VerifyFailed):
verify_result = escrow.unlock(SigHashPreimage(preimage),
PubKey(key_pub_A), Sig(sig_A),
PubKey(key_pub_E), Sig(sig_E),
Bytes(secret1)).verify(context)
def test_type_alias():
verify_result = struct_demo.main(
Female({
'name': Bytes(bytes.fromhex('7361746f736869206e616b616d6f746f')),
'leftHanded': False,
'age': 33,
'addr': Bytes(bytes.fromhex('68656c6c6f20776f726c6421'))
})).verify()
assert verify_result == True
def test_verify_wrong_sig():
seed = b'\xff'
p, q = rabin.gen_prime_pair(seed)
n = p * q
message = bytes.fromhex('00112233445566778899aabbccddeeff')
sig, pad = rabin.sign_rabin(p, q, message)
padding_bytes = b'\x00' * (pad + 1)
verify_result = rabin_obj.verifySig(sig + 1, Bytes(message),
Bytes(padding_bytes), n).verify()
assert verify_result == False
def test_wrong_value3():
with pytest.raises(bitcoinx.VerifyFailed):
verify_result = struct_demo.main(
Person({
'name':
Bytes(bytes.fromhex('7361746c736869206e616b616d6f746f')),
'leftHanded':
False,
'age':
33,
'addr':
Bytes(bytes.fromhex('68656c6c6f20776f726c6421'))
})).verify()
def sale(n_bought, pkh, pub_key):
context = scryptlib.utils.create_dummy_input_context()
context.utxo.script_pubkey = ats.locking_script
context.utxo.value = input_sats
new_data_part = ats.data_part << pub_key.to_bytes(
) + scryptlib.utils.get_push_int(n_bought)[1:]
new_locking_script = Script(ats.code_part.to_bytes() +
new_data_part.to_bytes())
change_sats = input_sats - n_bought * SATS_PER_TOKEN
out_sats = input_sats + n_bought * SATS_PER_TOKEN
# Counter output
tx_out = TxOutput(value=out_sats, script_pubkey=new_locking_script)
context.tx.outputs.append(tx_out)
# Change output
change_out = TxOutput(
change_sats,
P2PKH_Address(pub_key.hash160(), Bitcoin).to_script())
context.tx.outputs.append(change_out)
preimage = scryptlib.utils.get_preimage_from_input_context(
context, sighash_flag)
verify_result = ats.buy(SigHashPreimage(preimage), Ripemd160(pkh),
change_sats, Bytes(pub_key.to_bytes()),
n_bought).verify(context)
assert verify_result == True
return new_data_part
def test_unlock_wrong():
charlie = MaleAAA({
'age': 2,
'name': Bytes(str.encode('Charlie', encoding='utf-8')),
'token': 10
})
verify_result = alias.unlock(charlie).verify()
assert verify_result == False
def test_unlock_ST2_correct():
verify_result = arraydemo.unlockST2(ST2(
{
'x': True,
'y': Bytes('68656c6c6f20776f726c6420'),
'st3': ST3({
'x': True,
'y': [4, 5, 6],
'st1': ST1({
'x': False,
'y': Bytes('68656c6c6f20776f726c6420'),
'i': 42
})
})
})
).verify()
assert verify_result == True
def test_verify_main():
bounds = [0x0, 0xfc, 0xffff]
for i, bound in enumerate(bounds[:-1]):
for j in range(0, 10):
n = random.randint(0, 2**32)
m = random.randint(bound, bounds[i + 1])
#h = random.randbytes(m)
h = os.urandom(m)
verify_result = demo.main(n % 2 == 0, Bytes(h), n).verify()
assert verify_result == True
def test_verify_correct_add_leaves():
old_merkle_root = Bytes(
'f981662b1dcd91b2569a56fce8c590b04bc062ee22d459e49bc507638c8099a2')
last_leaf = Bytes(
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce')
last_merkle_path = Bytes(''.join([
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce',
'01',
'4295f72eeb1e3507b8461e240e3b8d18c1e7bd2f1122b11fc9ec40a65894031a',
'00'
]))
new_leaf = Bytes(
'4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a')
new_merkle_root = Bytes(
'cd53a2ce68e6476c29512ea53c395c7f5d8fbcb4614d89298db14e2a5bdb5456')
verify_result = merkle_tree_test.testAddLeaf(last_leaf, last_merkle_path,
old_merkle_root, new_leaf,
new_merkle_root).verify()
assert verify_result == True
old_merkle_root = Bytes(
'cd53a2ce68e6476c29512ea53c395c7f5d8fbcb4614d89298db14e2a5bdb5456')
last_leaf = Bytes(
'4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a')
last_merkle_path = Bytes(''.join([
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce',
'00',
'4295f72eeb1e3507b8461e240e3b8d18c1e7bd2f1122b11fc9ec40a65894031a',
'00'
]))
new_leaf = Bytes(
'ef2d127de37b942baad06145e54b0c619a1f22327b2ebbcfbec78f5564afe39d')
new_merkle_root = Bytes(
'0abb51d233d9b6172ff6fcb56b4ef172f550da4cb15aa328ebf43751288b8011')
verify_result = merkle_tree_test.testAddLeaf(last_leaf, last_merkle_path,
old_merkle_root, new_leaf,
new_merkle_root).verify()
assert verify_result == True
def test_verify_correct():
context = scryptlib.utils.create_dummy_input_context()
context.utxo.script_pubkey = p2sh.locking_script
context.utxo.value = input_sats
tx_out = TxOutput(value=input_sats, script_pubkey=demo_contract.code_part)
context.tx.outputs.append(tx_out)
preimage = scryptlib.utils.get_preimage_from_input_context(context)
verify_result = p2sh.redeem(Bytes(demo_contract.code_part.to_bytes()),
SigHashPreimage(preimage)).verify(context)
assert verify_result == True
def test_merge(input_idx, balance0, balance1):
context = scryptlib.utils.create_dummy_input_context()
context.utxo.value = in_sats
context.input_index = input_idx
tx_in = TxInput(context.tx.inputs[0].prev_hash, 1, Script(), 0xffffffff)
context.tx.inputs.append(tx_in)
prev_txid = context.tx.inputs[0].prev_hash
prevouts = prev_txid + b'\x00\x00\x00\x00' + prev_txid + b'\x01\x00\x00\x00'
new_locking_script = Script(token.code_part.to_bytes() + b'\x23' +
key_pub_2.to_bytes() + scryptlib.utils.get_push_int(balance0)[1:] + scryptlib.utils.get_push_int(balance1)[1:])
tx_out = TxOutput(value=out_sats, script_pubkey=new_locking_script)
context.tx.outputs.append(tx_out)
if input_idx == 0:
balance = balance1
context.utxo.script_pubkey = locking_script_0
key_to_sign = key_priv_0
token.set_data_part(b'\x23' + data_part_0)
else:
balance = balance0
context.utxo.script_pubkey = locking_script_1
key_to_sign = key_priv_1
token.set_data_part(b'\x23' + data_part_1)
sighash_flag = SigHash(SigHash.ALL | SigHash.FORKID)
#preimage = scryptlib.utils.get_preimage_from_input_context(context, sighash_flag)
if input_idx == 0:
preimage = scryptlib.utils.get_preimage(context.tx, input_idx, in_sats, locking_script_0, sighash_flag=sighash_flag)
else:
preimage = scryptlib.utils.get_preimage(context.tx, input_idx, in_sats, locking_script_1, sighash_flag=sighash_flag)
if input_idx == 0:
sighash = context.tx.signature_hash(input_idx, in_sats, locking_script_0, sighash_flag)
else:
sighash = context.tx.signature_hash(input_idx, in_sats, locking_script_1, sighash_flag)
sig = key_to_sign.sign(sighash, hasher=None)
sig = sig + pack_byte(sighash_flag)
return token.merge(
Sig(sig),
PubKey(key_pub_2),
Bytes(prevouts),
balance,
out_sats,
SigHashPreimage(preimage)
).verify(context)
def test_verify_correct_merkle_root():
merkle_root = Bytes(
'cd53a2ce68e6476c29512ea53c395c7f5d8fbcb4614d89298db14e2a5bdb5456')
leaf = Bytes(
'6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b')
merkle_path = Bytes(''.join([
'd4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35',
'01',
'20ab747d45a77938a5b84c2944b8f5355c49f21db0c549451c6281c91ba48d0d',
'01'
]))
verify_result = merkle_tree_test.testCalculateMerkleRoot(
leaf, merkle_path, merkle_root).verify()
assert verify_result == True
leaf = Bytes(
'4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a')
merkle_path = Bytes(''.join([
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce',
'00',
'4295f72eeb1e3507b8461e240e3b8d18c1e7bd2f1122b11fc9ec40a65894031a',
'00'
]))
verify_result = merkle_tree_test.testCalculateMerkleRoot(
leaf, merkle_path, merkle_root).verify()
assert verify_result == True
merkle_root = Bytes(
'f58e5706462d76bde8db3498c15883aabe4585180e3cba0e7b15bb6f45ac3994')
leaf = Bytes(
'ef2d127de37b942baad06145e54b0c619a1f22327b2ebbcfbec78f5564afe39d')
merkle_path = Bytes(''.join([
'0000000000000000000000000000000000000000000000000000000000000000',
'01',
'0000000000000000000000000000000000000000000000000000000000000000',
'01',
'cd53a2ce68e6476c29512ea53c395c7f5d8fbcb4614d89298db14e2a5bdb5456',
'00'
]))
verify_result = merkle_tree_test.testCalculateMerkleRoot(
leaf, merkle_path, merkle_root).verify()
assert verify_result == True
def test_verify_correct():
verify_result = hash_puzzle.verify(Bytes(secret)).verify()
assert verify_result == True
def test_verify_incorrect():
verify_result = hash_puzzle.verify(Bytes(secret + b'ff')).verify()
assert verify_result == False
def test_verify_incorrect():
with pytest.raises(bitcoinx.VerifyFailed):
simple_BVM.unlock(Bytes(input_script + '52')).verify()
def test_verify_pushdata_2():
verify_result = demo.testBytes(Bytes(b'\x11' * (2**8))).verify()
assert verify_result == True
def test_verify_checklenfail_correct():
with pytest.raises(bitcoinx.VerifyFailed):
asm.checkLenFail(Bytes('1122ffee'), 4).verify()
def test_verify_correct():
verify_result = simple_BVM.unlock(Bytes(input_script)).verify()
assert verify_result == True
def test_verify_checklen_correct():
verify_result = asm.checkLen(Bytes('1122ffee'), 4).verify()
assert verify_result == True
],
[
[
13, 14, 15, 16
],
[
17, 18, 19, 20
],
[
21, 22, 23, 24
]
]
],
[[[ST1({
'x': False,
'y': Bytes('aa'),
'i': 1
}), ST1({
'y': Bytes('bb'),
'x': True,
'i': 2
})], [ST1({
'x': False,
'y': Bytes('cc'),
'i': 3
}), ST1({
'y': Bytes('dd'),
'x': True,
'i': 4
})]], [[ST1({
'x': False,
Male = type_classes['Male']
Female = type_classes['Female']
Integer = type_classes['Integer']
Name = type_classes['Name']
Token = type_classes['Token']
Tokens = type_classes['Tokens']
Coinbase = type_classes['Coinbase']
Time = type_classes['Time']
Height = type_classes['Height']
MaleAAA = type_classes['MaleAAA']
Person = type_classes['Person']
Block = type_classes['Block']
bob = MaleAAA({
'age': 8,
'name': Bytes(str.encode('Bob', encoding='utf-8')),
'token': 80
})
alice = Female({
'age': 7,
'name': Bytes(str.encode('Alice', encoding='utf-8')),
'token': 150
})
alias = Alias(alice)
def test_array_unlock_correct():
verify_result = alias.unlock(bob).verify()
assert verify_result == True
import bitcoinx
contract = './test/res/structdemo.scrypt'
compiler_result = scryptlib.utils.compile_contract(contract)
desc = compiler_result.to_desc()
StructDemo = scryptlib.contract.build_contract_class(desc)
type_classes = scryptlib.contract.build_type_classes(desc)
Person = type_classes['Person']
Female = type_classes['Female']
struct_demo = StructDemo(
Person({
'name': Bytes(bytes.fromhex('7361746f736869206e616b616d6f746f')),
'leftHanded': False,
'age': 33,
'addr': Bytes(bytes.fromhex('68656c6c6f20776f726c6421'))
}))
def test_correct():
verify_result = struct_demo.main(
Person({
'name': Bytes(bytes.fromhex('7361746f736869206e616b616d6f746f')),
'leftHanded': False,
'age': 33,
'addr': Bytes(bytes.fromhex('68656c6c6f20776f726c6421'))
})).verify()
assert verify_result == True
def test_verify_pushdata_1():
verify_result = demo.testBytes(Bytes(b'\x11' * 76)).verify()
assert verify_result == True
verify_result = demo.testBytes(Bytes(b'\xff' * (0x100 - 1))).verify()
assert verify_result == True
def test_verify_correct_update_leaves():
old_merkle_root = Bytes(
'cd53a2ce68e6476c29512ea53c395c7f5d8fbcb4614d89298db14e2a5bdb5456')
old_leaf = Bytes(
'6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b')
merkle_path = Bytes(''.join([
'd4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35',
'01',
'20ab747d45a77938a5b84c2944b8f5355c49f21db0c549451c6281c91ba48d0d',
'01'
]))
new_leaf = Bytes(
'ef2d127de37b942baad06145e54b0c619a1f22327b2ebbcfbec78f5564afe39d')
new_merkle_root = Bytes(
'b0e44f9adb044dffb32aa1e455456f9cc6ed27d11fb7d6196b4065a1a54ea1bd')
verify_result = merkle_tree_test.testUpdateLeaf(old_leaf, new_leaf,
merkle_path,
old_merkle_root,
new_merkle_root).verify()
assert verify_result == True
# Signle leaf
old_merkle_root = Bytes(
'dd0cb00641618c5f4184542383510d1d36cb2d94ac7086680cce4b7134021ff3')
old_leaf = Bytes(
'df76677628c05bc234aefe31dfc20820e546354db1a096e6b3cef9730fcb4475')
merkle_path = Bytes(''.join([
'df76677628c05bc234aefe31dfc20820e546354db1a096e6b3cef9730fcb4475',
'01'
]))
new_leaf = Bytes(
'07cf2a3098945e378f269c572556e8963dfb02e87a923f243922e68126d75484')
new_merkle_root = Bytes(
'7a5e911a33379d003d436db3eee3699381416aadfc30367f81ab71877263647d')
verify_result = merkle_tree_test.testUpdateLeaf(old_leaf, new_leaf,
merkle_path,
old_merkle_root,
new_merkle_root).verify()
assert verify_result == True
# Single branch
old_merkle_root = Bytes(
'4d0de4a362a753cdad6370827fb46c2887d86ca990a74da009ad3b1922daff66')
old_leaf = Bytes(
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce')
merkle_path = Bytes(''.join([
'4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce',
'01',
'ad88f6375d55f0d5839f873f632bef974c9b20d5e764069042b1deefc9fe3b30',
'01',
'6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b',
'00'
]))
new_leaf = Bytes(
'4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a')
new_merkle_root = Bytes(
'6cce63479bef0c755231553faad0928b6de6c2a701a02ef47bc53b098b718244')
verify_result = merkle_tree_test.testUpdateLeaf(old_leaf, new_leaf,
merkle_path,
old_merkle_root,
new_merkle_root).verify()
assert verify_result == True
def test_verify_bytes():
verify_result = demo.testBytes(Bytes('1100')).verify()
assert verify_result == True
verify_result = demo.testBytes(Bytes('1100ffff')).verify()
assert verify_result == True
