def test_verify_wrong_addr():
key_priv = PrivateKey.from_arbitrary_bytes(b'123test')
key_pub = key_priv.public_key
pkh = key_pub.hash160()
pkh_0_out_wrong = TxOutput(in_sats - miner_fee,
P2PKH_Address(pkh, Bitcoin).to_script())
context = create_input_context(in_sats, acs.locking_script,
pkh_0_out_wrong)
preimage = scryptlib.utils.get_preimage_from_input_context(
context, sighash_flag)
verify_result = acs.unlock(SigHashPreimage(preimage)).verify(context)
assert verify_result == False
import pytest
import scryptlib.utils
import scryptlib.contract
from scryptlib.types import Int, PubKey, Sig, SigHashPreimage, Bytes
import bitcoinx
from bitcoinx import PrivateKey, TxOutput, SigHash, pack_byte, Script, sha256, TxInput
key_priv_0 = PrivateKey.from_arbitrary_bytes(b'test123')
key_pub_0 = key_priv_0.public_key
key_priv_1 = PrivateKey.from_arbitrary_bytes(b'123test')
key_pub_1 = key_priv_1.public_key
key_priv_2 = PrivateKey.from_arbitrary_bytes(b'te123st')
key_pub_2 = key_priv_2.public_key
in_sats = 100000
out_sats = 22222
contract = './test/res/tokenUtxo.scrypt'
compiler_result = scryptlib.utils.compile_contract(contract)
desc = compiler_result.to_desc()
Token = scryptlib.contract.build_contract_class(desc)
token = Token()
def test_verify_split_in_two():
data_part = scryptlib.utils.get_push_item(key_pub_0.to_bytes() + scryptlib.utils.get_push_int(10)[1:] + scryptlib.utils.get_push_int(90)[1:])
import pytest
import scryptlib.utils
import scryptlib.contract
from scryptlib.types import Sig, PubKey, PubKeyHash
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()
wrong_key_priv = PrivateKey.from_arbitrary_bytes(b'somethingelse')
wrong_key_pub = wrong_key_priv.public_key
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(PubKeyHash(pubkey_hash))
context = scryptlib.utils.create_dummy_input_context()
sighash_flag = SigHash(SigHash.ALL | SigHash.FORKID)
input_idx = 0
utxo_satoshis = context.utxo.value
sighash = context.tx.signature_hash(input_idx, utxo_satoshis,
p2pkh_obj.locking_script, sighash_flag)
def get_eckey_from_password(password: str) -> PrivateKey:
secret = hashlib.pbkdf2_hmac('sha512',
password.encode('utf-8'),
b'',
iterations=1024)
return PrivateKey.from_arbitrary_bytes(secret)
import pytest import hashlib import scryptlib.utils import scryptlib.contract from scryptlib.types import Int, PubKey, Sig, SigHashPreimage, Ripemd160, Bytes import bitcoinx from bitcoinx import PrivateKey, TxOutput, SigHash, pack_byte, Script, TxInput, P2PKH_Address, Bitcoin key_priv = PrivateKey.from_arbitrary_bytes(b'test0') key_pub = key_priv.public_key pkh = key_pub.hash160() payout_addr = pkh change_addr = pkh contract = './test/res/merkleToken.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() input_sats = 100000 sat_price = 100 Token = scryptlib.contract.build_contract_class(desc) token = Token(sat_price) change_sats = 100 sighash_flag = SigHash(SigHash.ANYONE_CAN_PAY | SigHash.ALL | SigHash.FORKID) #def test_verify_buy_token():
prev_txid = prev_tx.hash()
utxo_idx = 0
n_sequence = 0xffffffff
unlocking_script = Script()
curr_in = TxInput(prev_txid, utxo_idx, unlocking_script, n_sequence)
curr_tx = Tx(tx_version, [curr_in], [new_out], tx_locktime)
input_idx = 0
return TxInputContext(curr_tx, input_idx, utxo, is_utxo_after_genesis=True)
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)
h_secret_wrong = sha256(secret_wrong)
k_wrong = h_secret
G = PublicKey.from_hex(
'0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
Q = G.multiply(k)
r, _ = Q.to_point()
r = int_to_be_bytes(r)
if r[0] & 0x80:
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
import pytest import hashlib import scryptlib.utils import scryptlib.contract from scryptlib.types import SigHashPreimage, Int, Ripemd160, Sha256, PubKey, Sig, Bytes import bitcoinx from bitcoinx import SigHash, TxOutput, Script, PrivateKey, P2PKH_Address, Bitcoin, pack_byte contract = './test/res/escrow.scrypt' compiler_result = scryptlib.utils.compile_contract(contract) desc = compiler_result.to_desc() key_priv_A = PrivateKey.from_arbitrary_bytes(b'test0') key_pub_A = key_priv_A.public_key pkh_A = key_pub_A.hash160() key_priv_B = PrivateKey.from_arbitrary_bytes(b'test1') key_pub_B = key_priv_B.public_key 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()
