def __test__(self, version, height, items, string, **kwargs):
utx1 = UnspentTransaction.deserialize(StringIO(string))
utx2 = UnspentTransaction.deserialize(StringIO(string))
self.assertTrue(utx1 == utx2)
self.assertFalse(utx1 != utx2)
self.assertEqual(utx1.serialize(), utx2.serialize())
utx2.version = version - 1
self.assertFalse(utx1 == utx2)
self.assertTrue(utx1 != utx2)
self.assertNotEqual(utx1.serialize(), utx2.serialize())
utx2.version = version
self.assertTrue(utx1 == utx2)
self.assertEqual(utx1.serialize(), utx2.serialize())
utx2.height = height + 1
self.assertFalse(utx1 == utx2)
self.assertTrue(utx1 != utx2)
self.assertNotEqual(utx1.serialize(), utx2.serialize())
utx2.height = height
if version in (2, ):
utx2.reference_height = height - 1
self.assertFalse(utx1 == utx2)
self.assertTrue(utx1 != utx2)
self.assertNotEqual(utx1.serialize(), utx2.serialize())
utx2.reference_height = utx1.reference_height
self.assertTrue(utx1 == utx2)
self.assertEqual(utx1.serialize(), utx2.serialize())
del utx2[next(six.iterkeys(utx2))]
if utx2:
self.assertFalse(utx1 == utx2)
self.assertTrue(utx1 != utx2)
self.assertNotEqual(utx1.serialize(), utx2.serialize())
def __test__(self, script, string):
file_ = StringIO()
pickler = ScriptPickler(file_)
pickler.dump(script)
self.assertEqual(file_.getvalue(), string)
file_ = StringIO()
pickler = ScriptPickler()
pickler.dump(script, file=file_)
self.assertEqual(file_.getvalue(), string)
self.assertEqual(pickler.dumps(script), string)
def __test__(self, value, children, str_, composable, patricia):
pn = MemoryComposableAuthTree.deserialize(StringIO(str_))
self.assertEqual(pn.value, value)
self.assertEqual(
list((child.prefix, child.node) for child in pn.children),
children)
self.assertEqual(pn.hash, composable)
pn2 = MemoryPatriciaAuthTree.deserialize(StringIO(str_))
self.assertEqual(pn2.value, value)
self.assertEqual(
list((child.prefix, child.node) for child in pn2.children),
children)
self.assertEqual(pn2.hash, patricia)
def get_block(rpc, session, hash):
block = session.query(core.Block).filter_by(hash=hash).first()
if block is not None:
return block, block.transactions
try:
hash_string = hash_integer_to_string(hash)
block_dict = rpc.getblock(hash_string)
except HTTPError:
raise MissingBlockHeader(hash)
kwargs = {}
kwargs['version'] = int(block_dict['version'])
if int(block_dict['height']) > 0:
kwargs['parent_hash'] = hash_string_to_integer(
block_dict['previousblockhash'])
else:
kwargs['parent_hash'] = 0
kwargs['merkle_hash'] = hash_string_to_integer(block_dict['merkleroot'])
kwargs['time'] = datetime.utcfromtimestamp(block_dict['time'])
kwargs['bits'] = hash_string_to_integer(block_dict['bits'], 4)
kwargs['nonce'] = int(block_dict['nonce'])
block = core.Block(**kwargs)
assert block.hash == hash
for tx_hash_string in block_dict['tx']:
tx_hash = hash_string_to_integer(tx_hash_string)
tx = session.query(core.Transaction).filter_by(hash=tx_hash).first()
if tx is None:
try:
tx_raw = rpc.getrawtransaction(tx_hash_string)
except HTTPError:
raise MissingTransaction(tx_hash)
tx_file = StringIO(tx_raw.decode('hex'))
tx = core.Transaction.deserialize(tx_file)
assert not tx_file.read()
assert tx.hash == tx_hash
block.transactions.append(tx)
session.add(block)
session.flush()
return block, block.transactions
def get_block(rpc, session, hash):
block = session.query(core.Block).filter_by(hash=hash).first()
if block is not None:
return block, block.transactions
try:
hash_string = hash_integer_to_string(hash)
block_dict = rpc.getblock(hash_string)
except HTTPError:
raise MissingBlockHeader(hash)
kwargs = {}
kwargs['version'] = int(block_dict['version'])
if int(block_dict['height']) > 0:
kwargs['parent_hash'] = hash_string_to_integer(block_dict['previousblockhash'])
else:
kwargs['parent_hash'] = 0
kwargs['merkle_hash'] = hash_string_to_integer(block_dict['merkleroot'])
kwargs['time'] = datetime.utcfromtimestamp(block_dict['time'])
kwargs['bits'] = hash_string_to_integer(block_dict['bits'], 4)
kwargs['nonce'] = int(block_dict['nonce'])
block = core.Block(**kwargs)
assert block.hash == hash
for tx_hash_string in block_dict['tx']:
tx_hash = hash_string_to_integer(tx_hash_string)
tx = session.query(core.Transaction).filter_by(hash=tx_hash).first()
if tx is None:
try:
tx_raw = rpc.getrawtransaction(tx_hash_string)
except HTTPError:
raise MissingTransaction(tx_hash)
tx_file = StringIO(tx_raw.decode('hex'))
tx = core.Transaction.deserialize(tx_file)
assert not tx_file.read()
assert tx.hash == tx_hash
block.transactions.append(tx)
session.add(block)
session.flush()
return block, block.transactions
def __test__(self, version, height, items, string, **kwargs):
utx = UnspentTransaction.deserialize(StringIO(string))
self.assertEqual(utx.version, version)
self.assertEqual(utx.height, height)
if 'reference_height' in kwargs:
self.assertEqual(utx.reference_height,
kwargs['reference_height'])
for idx, output in items:
self.assertIn(idx, utx)
self.assertEqual(utx[idx], output)
self.assertEqual(utx.serialize(), string)
def process_result_value(self, value, dialect):
if value is None:
return None
file_ = StringIO(value)
bitlength = deserialize_varint(file_)
return self._implicit + Bits(bytes=file_.read(), length=bitlength)
# Python standard library, unit-testing
import unittest2
# Scenario unit-testing
from scenariotest import ScenarioMeta, ScenarioTest
from bitcoin.destination import *
from bitcoin.crypto import VerifyingKey
from bitcoin.script import *
from bitcoin.tools import StringIO
# ===----------------------------------------------------------------------===
PUBKEY = [
dict(verifying_key=VerifyingKey.deserialize(
StringIO(
'muqdFiyLkdVygf59nrWJFwJMHCBhdYdU2tXs8AUz7iWD'.decode('base58'))),
script=Script().join([
ScriptOp(data=('029b4b68495bb7cdc737fada24b80adff2b7a08d77424368'
'e7ae56f5f14980b282').decode('hex')),
ScriptOp(OP_CHECKSIG)
])),
dict(verifying_key=VerifyingKey.deserialize(
StringIO(
'28kSUszMTVjiXUNNjN8aFMzj4Ztfp36ktAtoPgqUW1Fy7'.decode('base58'))),
script=Script().join([
ScriptOp(data=('03d0e86fa3d42ebcd38019e976dd66d32d4339060f705b8f'
'70f407647aa6ff52de').decode('hex')),
ScriptOp(OP_CHECKSIG)
])),
dict(verifying_key=VerifyingKey.deserialize(
StringIO((
magic = parameters.magic,
port = parameters.port,
genesis = parameters.genesis[:80],
genesis_hash = hash256(parameters.genesis[:80]).intdigest(),
testnet = parameters.testnet,
pubkey_hash_prefix = parameters.pubkey_hash_prefix,
script_hash_prefix = parameters.script_hash_prefix,
secret_prefix = parameters.secret_prefix)
session.add(chain)
session.commit()
genesis_block_hash_string = rpc.getblockhash(0)
genesis_block_hash = hash_string_to_integer(genesis_block_hash_string)
genesis_file = StringIO(CHAIN_PARAMETERS[FLAGS.network].genesis)
genesis_block = core.Block.deserialize(genesis_file)
genesis_transactions = list(deserialize_list(genesis_file, core.Transaction.deserialize))
assert not genesis_file.read()
for tx in genesis_transactions:
genesis_block.transactions.append(
session.query(core.Transaction).filter_by(hash=tx.hash).first() or tx)
assert genesis_block.hash == genesis_block_hash
assert genesis_block.merkle_hash == merkle(genesis_transactions)
query = session.query(core.Block).filter_by(hash=genesis_block.hash)
if query.count():
genesis_block = query.first()
else:
def process_result_value(self, value, dialect):
if value is None:
return None
file_ = StringIO(value)
bitlength = deserialize_varint(file_)
return self._implicit + Bits(bytes=file_.read(), length=bitlength)
def process_result_value(self, value, dialect):
if value is None: return None
return deserialize_beint(StringIO(value), len(value))
def hash_string_to_integer(string, size=32):
return deserialize_hash(StringIO(string.decode('hex')[::-1]), size)
port=parameters.port,
genesis=parameters.genesis[:80],
genesis_hash=hash256(
parameters.genesis[:80]).intdigest(),
testnet=parameters.testnet,
pubkey_hash_prefix=parameters.pubkey_hash_prefix,
script_hash_prefix=parameters.script_hash_prefix,
secret_prefix=parameters.secret_prefix)
session.add(chain)
session.commit()
genesis_block_hash_string = rpc.getblockhash(0)
genesis_block_hash = hash_string_to_integer(genesis_block_hash_string)
genesis_file = StringIO(CHAIN_PARAMETERS[FLAGS.network].genesis)
genesis_block = core.Block.deserialize(genesis_file)
genesis_transactions = list(
deserialize_list(genesis_file, core.Transaction.deserialize))
assert not genesis_file.read()
for tx in genesis_transactions:
genesis_block.transactions.append(
session.query(core.Transaction).filter_by(hash=tx.hash).first()
or tx)
assert genesis_block.hash == genesis_block_hash
assert genesis_block.merkle_hash == merkle(genesis_transactions)
query = session.query(core.Block).filter_by(hash=genesis_block.hash)
if query.count():
