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)
