def test_verify_with_change(): deposit_sats = 100000 input_sats = 100000 output_sats = deposit_sats + input_sats change_sats = 547 faucet.set_data_part(scryptlib.utils.get_push_int(1602553516)) context = scryptlib.utils.create_dummy_input_context() context.utxo.script_pubkey = faucet.locking_script context.utxo.value = input_sats tx_out_0 = TxOutput(value=output_sats, script_pubkey=faucet.locking_script) context.tx.outputs.append(tx_out_0) tx_out_1 = TxOutput(value=change_sats, script_pubkey=P2PKH_Address(pkh, Bitcoin).to_script()) context.tx.outputs.append(tx_out_1) sighash_flag = SigHash(SigHash.ALL | SigHash.FORKID) preimage = scryptlib.utils.get_preimage_from_input_context( context, sighash_flag) verify_result = faucet.deposit(SigHashPreimage(preimage), deposit_sats, Ripemd160(pkh), change_sats).verify(context) assert verify_result == True with pytest.raises(bitcoinx.VerifyFailed): faucet.deposit(SigHashPreimage(preimage), deposit_sats, Ripemd160(pkh), change_sats + 1).verify(context)
def test_verify_withdraw(): withdraw_sats = 2000000 fee = 3000 input_sats = 10000000 output_sats = input_sats - withdraw_sats - fee mature_time = 1627122529 faucet.set_data_part(scryptlib.utils.get_push_int(mature_time)) context = scryptlib.utils.create_dummy_input_context() context.utxo.script_pubkey = faucet.locking_script context.utxo.value = input_sats new_locking_script = faucet.code_part << Script( scryptlib.utils.get_push_int(mature_time + 300)) tx_out_0 = TxOutput(value=output_sats, script_pubkey=new_locking_script) context.tx.outputs.append(tx_out_0) tx_out_1 = TxOutput(value=withdraw_sats, script_pubkey=P2PKH_Address(pkh, Bitcoin).to_script()) context.tx.outputs.append(tx_out_1) context.tx.inputs[0].sequence = 0xfffffffe context.tx.locktime = mature_time + 300 preimage = scryptlib.utils.get_preimage_from_input_context(context) verify_result = faucet.withdraw(SigHashPreimage(preimage), Ripemd160(pkh)).verify(context) assert verify_result == True # Wrong mature time context.tx.outputs = [] new_locking_script = faucet.code_part << Script( scryptlib.utils.get_push_int(mature_time + 299)) tx_out_0 = TxOutput(value=output_sats, script_pubkey=new_locking_script) context.tx.outputs.append(tx_out_0) tx_out_1 = TxOutput(value=withdraw_sats, script_pubkey=P2PKH_Address(pkh, Bitcoin).to_script()) context.tx.outputs.append(tx_out_1) context.tx.locktime = mature_time + 299 preimage = scryptlib.utils.get_preimage_from_input_context(context) with pytest.raises(bitcoinx.VerifyFailed): faucet.withdraw(SigHashPreimage(preimage), Ripemd160(pkh)).verify(context)
def test_array_constructor_wrong_params(): with pytest.raises(Exception): arraydemo.testArrayConstructor( True, [ True, False ], [ False ], [ Ripemd160('2235c953af7c83cffa6f192477fb431941400162'), Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b') ] ).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_array_constructor_correct(): verify_result = arraydemo.testArrayConstructor( 33, [ True, False ], [ 3311, 333 ], [ Ripemd160('2235c953af7c83cffa6f192477fb431941400162'), Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b') ] ).verify() assert verify_result == True
def test_array_constructor_wrong_val(): with pytest.raises(bitcoinx.VerifyFailed): arraydemo.testArrayConstructor( 33, [ True, False ], [ 3312, 333 ], [ Ripemd160('2235c953af7c83cffa6f192477fb431941400162'), Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b') ] ).verify()
def test_verify_correct(): MultiSig = scryptlib.contract.build_contract_class(desc) multisig = MultiSig([Ripemd160(pkh_0), Ripemd160(pkh_1), Ripemd160(pkh_2)]) context = scryptlib.utils.create_dummy_input_context() sighash = context.tx.signature_hash(input_idx, context.utxo.value, multisig.locking_script, sighash_flag) sig_0 = key_priv_0.sign(sighash, hasher=None) + pack_byte(sighash_flag) sig_1 = key_priv_1.sign(sighash, hasher=None) + pack_byte(sighash_flag) sig_2 = key_priv_2.sign(sighash, hasher=None) + pack_byte(sighash_flag) verify_result = multisig.unlock( [PubKey(key_pub_0), PubKey(key_pub_1), PubKey(key_pub_2)], [Sig(sig_0), Sig(sig_1), Sig(sig_2)]).verify(context) assert verify_result == True
def test_verify_wrong_key(): MultiSig = scryptlib.contract.build_contract_class(desc) multisig = MultiSig([Ripemd160(pkh_0), Ripemd160(pkh_1), Ripemd160(pkh_2)]) context = scryptlib.utils.create_dummy_input_context() sighash = context.tx.signature_hash(input_idx, context.utxo.value, multisig.locking_script, sighash_flag) sig_0 = key_priv_0.sign(sighash, hasher=None) + pack_byte(sighash_flag) sig_1 = key_priv_1.sign(sighash, hasher=None) + pack_byte(sighash_flag) sig_2 = key_priv_1.sign(sighash, hasher=None) + pack_byte(sighash_flag) with pytest.raises(bitcoinx.NullFailError): verify_result = multisig.unlock( [PubKey(key_pub_0), PubKey(key_pub_2), PubKey(key_pub_2)], [Sig(sig_0), Sig(sig_1), Sig(sig_2)]).verify(context)
def test_verify_wrong_nextval(): subsequent_counter_val_bytes = scryptlib.utils.get_push_int( COUNTER_INITIAL_VAL + 2) new_locking_script = counter.code_part << Script( subsequent_counter_val_bytes) tx_out = TxOutput(value=out_sats, script_pubkey=new_locking_script) context.tx.outputs[0] = tx_out preimage = scryptlib.utils.get_preimage_from_input_context( context, sighash_flag) verify_result = counter.increment(SigHashPreimage(preimage), out_sats, Ripemd160(pkh_0), change_sats - 1).verify(context) assert verify_result == False
def test_follow(pkh_B, action, init_sats, input_sats, out_sats, change_sats): rps.set_data_part(player_A_data + b'\x00' * pub_key_hashlen + scryptlib.utils.get_push_int(action_INIT)[1:]) context = scryptlib.utils.create_dummy_input_context() context.utxo.script_pubkey = rps.locking_script context.utxo.value = init_sats new_data_part = player_A_data + pkh_B + scryptlib.utils.get_push_int( action)[1:] new_locking_script = Script(rps.code_part.to_bytes() + new_data_part) tx_out = TxOutput(value=out_sats, script_pubkey=new_locking_script) context.tx.outputs.append(tx_out) change_out = TxOutput(change_sats, P2PKH_Address(pkh_B, Bitcoin).to_script()) context.tx.outputs.append(change_out) preimage = scryptlib.utils.get_preimage_from_input_context( context, sighash_flag) return rps.follow(SigHashPreimage(preimage), action, Ripemd160(pkh_B), change_sats).verify(context)
contract = './test/res/p2sh.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() P2SH = scryptlib.contract.build_contract_class(desc) contract = './test/res/counter.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() DemoContract = scryptlib.contract.build_contract_class(desc) demo_contract = DemoContract() script_hash_sha256 = hashlib.sha256( demo_contract.code_part.to_bytes()).digest() script_hash = ripemd160(script_hash_sha256) p2sh = P2SH(Ripemd160(script_hash)) 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
type_classes = scryptlib.contract.build_type_classes(desc) ST1 = type_classes['ST1'] ST2 = type_classes['ST2'] ST3 = type_classes['ST3'] AliasST2 = type_classes['AliasST2'] MDArrayST1 = type_classes['MDArrayST1'] arraydemo = ArrayDemo(33, [ True, False ], [ 3311, 333 ], [ Ripemd160('2235c953af7c83cffa6f192477fb431941400162'), Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b') ], [ [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ], [ 9, 10, 11, 12 ] ], [ [
import bitcoinx from bitcoinx import SigHash, PrivateKey, Tx, TxInput, TxOutput, Script, pack_byte, JSONFlags, Bitcoin, hex_str_to_hash unlock_key_priv = PrivateKey.from_WIF( '****************************************************') unlock_key_pub = unlock_key_priv.public_key addr_dest = '1Pc1iF4g8iVmnu1puvGasSyDcwv2FS1VcH' prev_txid = 'c1543650beafbf646e75aeeae9b091e4c477362db4a18e740d3f9d2ae250c013' miner_fee = 120 contract = '../test/res/p2pkh.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() P2PKH = scryptlib.contract.build_contract_class(desc) p2pkh_obj = P2PKH(Ripemd160(addr_dest)) prev_tx_hash = hex_str_to_hash(prev_txid) prev_out_idx = 0 r = requests.get( 'https://api.whatsonchain.com/v1/bsv/main/tx/{}'.format(prev_txid)).json() prev_locking_script = Script.from_hex( r['vout'][prev_out_idx]['scriptPubKey']['hex']) unlocked_satoshis = int(r['vout'][prev_out_idx]['value'] * 10**8) out_satoshis = unlocked_satoshis - miner_fee n_sequence = 0xffffffff tx_input = TxInput(prev_tx_hash, prev_out_idx, None, n_sequence) tx_output = TxOutput(out_satoshis, p2pkh_obj.locking_script)
r0 = pack_byte(0) + r else: r0 = r r_hash = hash160(r0) # Ephermal key to generate the r signature key_priv_R = PrivateKey.from_arbitrary_bytes(b'123test') key_pub_R = key_priv_R.public_key contract = './test/res/rpuzzle.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() RPuzzle = scryptlib.contract.build_contract_class(desc) r_puzzle = RPuzzle(Ripemd160(r_hash)) utxo_satoshis = 100004 context = scryptlib.utils.create_dummy_input_context() context.utxo.script_pubkey = r_puzzle.locking_script context.utxo.value = utxo_satoshis sighash_flag = SigHash(SigHash.ALL | SigHash.FORKID) input_idx = 0 sighash = context.tx.signature_hash(input_idx, utxo_satoshis, r_puzzle.locking_script, sighash_flag) class MockHashFunc: def __init__(self, data): self.data = data
def test_array_ripemd160_correct(): verify_result = arraydemo.testArrayRipemd160([ Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b'), Ripemd160('0176de27477fb7ffd7c99a7e9b931c22fd125c2b')]).verify() assert verify_result == True
def test_verify_correct(): verify_result = counter.increment(SigHashPreimage(preimage), out_sats, Ripemd160(pkh_0), change_sats).verify(context) assert verify_result == True
import bitcoinx from bitcoinx import SigHash, PrivateKey, pack_byte key_priv = PrivateKey.from_arbitrary_bytes(b'test123') key_pub = key_priv.public_key pubkey_hash = key_pub.hash160() contract = './test/res/asm.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() Asm = scryptlib.contract.build_contract_class(desc) asm_vars = { 'Asm.p2pkh.pkh': Ripemd160(pubkey_hash), 'Asm.equalImpl.x': Int(11) } asm = Asm(asm_vars=asm_vars) def test_verify_double_correct(): verify_result = asm.double(222, 111).verify() assert verify_result == True def test_verify_double_wrong(): verify_result = asm.double(222, 121).verify() assert verify_result == False
def test_verify_wrong_sats2(): verify_result = counter.increment(SigHashPreimage(preimage), out_sats, Ripemd160(pkh_0), change_sats - 1).verify(context) assert verify_result == False
in_sats = 1200 miner_fee = 546 key_priv_0 = PrivateKey.from_arbitrary_bytes(b'test123') key_pub_0 = key_priv_0.public_key pkh_0 = key_pub_0.hash160() contract = './test/res/acs.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() AnyoneCanSpend = scryptlib.contract.build_contract_class(desc) acs = AnyoneCanSpend(Ripemd160(pkh_0)) pkh_0_out = TxOutput(in_sats - miner_fee, P2PKH_Address(pkh_0, Bitcoin).to_script()) context = create_input_context(in_sats, acs.locking_script, pkh_0_out) sighash_flag = SigHash(SigHash.ANYONE_CAN_PAY | SigHash.ALL | SigHash.FORKID) preimage = scryptlib.utils.get_preimage_from_input_context( context, sighash_flag) def test_verify_correct(): verify_result = acs.unlock(SigHashPreimage(preimage)).verify(context) assert verify_result == True
pkh_B = key_pub_B.hash160() key_priv_E = PrivateKey.from_arbitrary_bytes(b'test2') key_pub_E = key_priv_E.public_key pkh_E = key_pub_E.hash160() secret0 = b'abc' secret1 = b'def' h_secret0 = hashlib.sha256(secret0).digest() h_secret1 = hashlib.sha256(secret1).digest() fee = 1000 input_sats = 100000 Escrow = scryptlib.contract.build_contract_class(desc) escrow = Escrow(Ripemd160(pkh_A), Ripemd160(pkh_B), Ripemd160(pkh_E), Sha256(h_secret0), Sha256(h_secret1), fee) def test_verify_scenario_1(): 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 / 2 - fee), P2PKH_Address(pkh_A, Bitcoin).to_script()) context.tx.outputs.append(change_out) change_out = TxOutput(int(input_sats / 2 - fee), P2PKH_Address(pkh_B, Bitcoin).to_script()) context.tx.outputs.append(change_out)