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