def test_zcash_compact_enforcement(self): riemann.select_network('zcash_overwinter_main') with self.assertRaises(ValueError) as context: tx.VarInt.from_bytes(b'\xfd\x00\x00') self.assertIn('VarInt must be compact. Got:', str(context.exception)) with self.assertRaises(ValueError) as context: tx.VarInt.from_bytes(b'\xfe\x00\x00\x00\x00') self.assertIn('VarInt must be compact. Got:', str(context.exception))
def test_sighash_forkid_all_anyone_can_pay(self): riemann.select_network('bitcoin_cash_main') t = tx.Tx(self.version, self.none_flag, self.tx_ins, self.tx_outs, self.none_witnesses, self.lock_time) sighash = t.sighash_all( index=0, script=helpers.P2PKH1['ser']['ins'][0]['pk_script'], prevout_value=helpers.P2PKH1['ser']['ins'][0]['value'], anyone_can_pay=True) self.assertEqual(sighash, helpers.SIGHASH_FORKID['all_anyone_can_pay'])
def test_overwrites(self): riemann.select_network('decred_main') self.assertEqual( 'OP_BLAKE256', ser.hex_deserialize('a8')) self.assertEqual( 'a8', ser.hex_serialize('OP_BLAKE256')) self.assertEqual( 'OP_SHA256', ser.hex_deserialize('c0')) self.assertEqual( 'c0', ser.hex_serialize('OP_SHA256'))
def test_cashaddrs(self): riemann.select_network('bitcoin_cash_main') self.assertEqual(addr.make_legacy_p2sh_address('OP_IF'), helpers.OP_IF_P2SH) self.assertEqual(addr.make_sh_address('OP_IF'), helpers.OP_IF_CASHADDR) self.assertEqual( addr.make_legacy_p2pkh_address(helpers.CASHADDR_PUBKEY), helpers.LEGACY_P2PKH_ADDRESS) self.assertEqual(addr.make_pkh_address(helpers.CASHADDR_PUBKEY), helpers.CASHADDR_P2PKH_ADDRESS)
def test_make_decred_input_and_witness(self): riemann.select_network('decred_main') outpoint = tb.make_outpoint( tx_id_le=helpers.DCR['ser']['ins'][0]['hash'], index=0, tree=0) tx_in, witness = tb.make_witness_input_and_witness( outpoint=outpoint, sequence=helpers.DCR['human']['ins'][0]['sequence'], value=helpers.DCR['ser']['witnesses'][0]['value'], height=helpers.DCR['ser']['witnesses'][0]['height'], index=helpers.DCR['ser']['witnesses'][0]['index'], stack_script=helpers.DCR['ser']['witnesses'][0]['stack_script'], redeem_script=helpers.DCR['ser']['witnesses'][0]['redeem_script']) self.assertEqual(tx_in, helpers.DCR['ser']['tx']['in_unsigned']) self.assertEqual(witness, helpers.DCR['ser']['witnesses'][0]['witness'])
def test_make_sh_output_script(self): self.assertEqual(tb.make_sh_output_script('OP_IF'), helpers.OP_IF['output_script']) self.assertEqual( tb.make_sh_output_script( helpers.P2WSH['human']['witnesses'][0]['wit_script'], witness=True), helpers.P2WSH['ser']['ins'][0]['pk_script']) riemann.select_network('bitcoin_cash_main') with self.assertRaises(ValueError) as context: tb.make_sh_output_script( helpers.P2WSH['human']['witnesses'][0]['wit_script'], witness=True) self.assertIn( 'Network bitcoin_cash_main does not support witness scripts.', str(context.exception))
def test_cashaddrs(self): riemann.select_network('bitcoin_cash_main') self.assertEqual( addr.make_legacy_p2sh_address('OP_IF'), helpers.OP_IF['p2sh']) self.assertEqual( addr.make_sh_address('OP_IF'), helpers.OP_IF['cashaddr']) self.assertEqual( addr.make_legacy_p2pkh_address(helpers.CASHADDR['pubkey']), helpers.CASHADDR['legacy_p2pkh']) self.assertEqual( addr.make_pkh_address(helpers.CASHADDR['pubkey']), helpers.CASHADDR['p2pkh'])
def createMultiSigAddress(pubkey0, pubkey1, verbose=None): msig_script = examples.msig_two_two msig_scriptpubkey = msig_script.format(pk0=pubkey0, pk1=pubkey1) if verbose: print("Multi sig script: ", msig_scriptpubkey) riemann.select_network(NETWORK) if ZCASH in NETWORK: msig_address = addresses.make_p2sh_address(msig_scriptpubkey) elif BITCOIN in NETWORK: msig_address = addresses.make_p2wsh_address(msig_scriptpubkey) else: sys.exit("%s not supported" % NETWORK) # TODO: add BOLT opcode here for channel opening? redeem_script = msig_scriptpubkey script = serialization.serialize(redeem_script) return msig_address, script.hex()
async def zeta(header_q: Optional[asyncio.Queue] = None, prevout_q: Optional[asyncio.Queue] = None, network: str = 'bitcoin_main') -> Tuple[Any, Any]: ''' Main function. Starts the various tasks. Pass in queues to access task outputs (new headers/prevout events) Returns references to the tasks ''' # switch zeta and riemann over to whatever network we're using chain_name = os.environ.get('ZETA_NETWORK', network) riemann.select_network(chain_name) connection.init_conn(chain_name=chain_name) await electrum.electrum._make_client(chain_name) chain_task = asyncio.ensure_future(chain.sync(header_q, chain_name)) coin_task = asyncio.ensure_future(coins.sync(prevout_q)) return chain_task, coin_task
def test_make_pkh_output_script(self): self.assertEqual(tb.make_pkh_output_script(helpers.PK['ser'][0]['pk']), helpers.PK['ser'][0]['pkh_output']) self.assertEqual( tb.make_pkh_output_script(helpers.PK['ser'][0]['pk'], witness=True), helpers.PK['ser'][0]['pkh_p2wpkh_output']) riemann.select_network('bitcoin_cash_main') with self.assertRaises(ValueError) as context: tb.make_pkh_output_script(helpers.PK['ser'][0]['pk'], witness=True) self.assertIn( 'Network bitcoin_cash_main does not support witness scripts.', str(context.exception)) with self.assertRaises(ValueError) as context: tb.make_pkh_output_script('hello world') self.assertIn('Unknown pubkey format. Expected bytes. Got: ', str(context.exception))
def test_unsigned_input(self): outpoint = simple.outpoint( tx_id=helpers.P2PKH['human']['ins'][0]['hash'], index=helpers.P2PKH['human']['ins'][0]['index']) self.assertEqual( simple.unsigned_input( outpoint=outpoint), outpoint.to_bytes() + b'\x00' + b'\xFE\xFF\xFF\xFF') self.assertEqual( simple.unsigned_input( outpoint=outpoint, sequence=0x1234abcd), outpoint.to_bytes() + b'\x00' + b'\xcd\xab\x34\x12') self.assertEqual( simple.unsigned_input( outpoint=outpoint, redeem_script='11AA OP_CHECKSEQUENCEVERIFY'), outpoint.to_bytes() + b'\x00' + b'\xaa\x11\x00\x00') self.assertEqual( simple.unsigned_input( outpoint=outpoint, redeem_script='11AA OP_CHECKSEQUENCEVERIFY', sequence=0x1234abcd), outpoint.to_bytes() + b'\x00' + b'\xcd\xab\x34\x12') riemann.select_network('decred_main') outpoint = simple.outpoint( tx_id=helpers.DCR['human']['ins'][0]['hash'], index=helpers.DCR['human']['ins'][0]['index'], tree=helpers.DCR['human']['ins'][0]['tree']) self.assertEqual( simple.unsigned_input( outpoint=outpoint, sequence=helpers.DCR['human']['ins'][0]['sequence']), helpers.DCR['ser']['tx']['in_unsigned'])
def test_guess_version(self): self.assertEqual(simple.guess_version('OP_IF'), 1) self.assertEqual(simple.guess_version('OP_CHECKSEQUENCEVERIFY'), 2) riemann.select_network('zcash_sprout_main') self.assertEqual(simple.guess_version('OP_IF'), 1) riemann.select_network('zcash_overwinter_main') self.assertEqual(simple.guess_version('OP_IF'), 3) riemann.select_network('zcash_sapling_main') self.assertEqual(simple.guess_version('OP_IF'), 4)
def setUp(self): riemann.select_network('zcash_overwinter_main')
def setUp(self): riemann.select_network('zcash_sprout_main')
def test_not_overwinter(self): riemann.select_network('zcash_sprout_main') with self.assertRaises(ValueError) as context: tx.OverwinterTx(None, None, None, None, None, None, None) self.assertIn('OverwinterTx not supported by network ', str(context.exception))
def test_overwinter_snowflake(self, mock_tx): # TODO: Improve riemann.select_network('zcash_overwinter_main') mock_tx.OverwinterTx.return_value = 0 self.assertEqual(tb.make_tx(0, 0, 0, 0, expiry=0), 0)
def test_sprout_snowflake(self, mock_tx): # TODO: Improve riemann.select_network('zcash_sprout_main') mock_tx.SproutTx.return_value = 0 self.assertEqual(tb.make_tx(0, 0, 0, 0, tx_joinsplits=[]), 0)
chain_name = os.environ.get('ZETA_NETWORK', network) riemann.select_network(chain_name) connection.init_conn(chain_name=chain_name) await electrum.electrum._make_client(chain_name) chain_task = asyncio.ensure_future(chain.sync(header_q, chain_name)) coin_task = asyncio.ensure_future(coins.sync(prevout_q)) return chain_task, coin_task if __name__ == '__main__': # start tracking header_q: asyncio.Queue = asyncio.Queue() prevout_q: asyncio.Queue = asyncio.Queue() # store the sample address chain_name = os.environ.get('ZETA_NETWORK', 'bitcoin_main') riemann.select_network(chain_name) connection.init_conn(chain_name=chain_name) # addresses.store_address('tb1qk0mul90y844ekgqpan8mg9lljasd59ny99ata4') asyncio.ensure_future(zeta(header_q, prevout_q)) # wait a few seconds then start the status updater asyncio.ensure_future(_status_updater()) asyncio.ensure_future(_report_new_headers(header_q)) asyncio.ensure_future(_report_new_prevouts(prevout_q)) asyncio.get_event_loop().run_forever()
def test_get_current_network(self): for n in networks.SUPPORTED: riemann.select_network(n) self.assertIs(riemann.get_current_network(), networks.SUPPORTED[n])
def setUp(self): riemann.select_network('zcash_overwinter_main') self.tx = tx.OverwinterTx.from_bytes(helpers.RAW_TX)
def make_several_auctions( tx_id: str, index: int, control_addr: str, control_addr_keypair: Tuple[str, str], prevout_value: int, start_nonce: int, contract_address: str, reqDiff: int, eth_value: int, eth_privkey: str, num_auctions: int, recipient: str, form: List[Tuple[int, int]], network_id: int = 1) -> Tuple[tx.Tx, List[str], List[str]]: ''' Args: tx_id (str): A txid containing an output held by control_addr index (int): The index controlled control_addr (str): the addr controlling the outpoint described above control_addr_keypair (Tuple(str, str)): the keypair to the control addr prevout_value (int): The value of the prevout start_nonce (int): the ethereum account nonce to use in the first tx contract_address (str): the ether auction contract eth_value (int): the amount of ethereum in wei to sell in each auc eth_privkey (str): the privkey to an eth account num_auctions (int): the number of auctions to make recipient (str): the bitcoin address to send proceeds to form list(tuple): the price/timelock tuples for the auctions network_id (int): ether network id, 1 for main, 3 for ropsten Returns: tuple(riemann.tx.Tx, List(str), List(str)): the Bitcoin tx, the ether data blobs, and the signed Ethereum txns ''' if network_id != 1: riemann.select_network('bitcoin_test') split_tx = make_and_sign_split_tx( tx_id=tx_id, index=index, prevout_value=prevout_value, control_addr=control_addr, control_addr_keypair=control_addr_keypair, num_auctions=num_auctions, change_addr=recipient) split_tx_id = split_tx.tx_id.hex() prevout_tuples = [(split_tx_id, i, 550) for i in range(num_auctions)] partial_txns = pt.multidutch_as_hex(prevouts=prevout_tuples, recipient_addr=recipient, format_tuples=form, keypair=control_addr_keypair) ether_blobs = [ iw.create_open_data(partial_tx=p[0], reservePrice=1000000, reqDiff=reqDiff, asset=ETH_ZERO_ADDRESS, value=eth_value).hex() for p in zip(partial_txns, range(len(partial_txns))) ] unsigned_ether = [ iw.create_open_tx(partial_tx=p[0], reservePrice=1000000, reqDiff=reqDiff, asset=ETH_ZERO_ADDRESS, value=eth_value, nonce=start_nonce + p[1], gas_price=15 * GWEI, start_gas=500000, contract_address=contract_address, network_id=network_id) for p in zip(partial_txns, range(len(partial_txns))) ] secret_key = bytes.fromhex(eth_privkey) signed_ether_txns = [ tx.sign(secret_key).serialize().hex() for tx in unsigned_ether ] return split_tx, ether_blobs, signed_ether_txns
import riemann from riemann import simple, utils from riemann.encoding import addresses as addr riemann.select_network('zcash_sapling_main') # Needs a 32 byte hash, alice's pubkey, a timeout, and bob's pubkey htlc_redeem_script = ( 'OP_IF ' 'OP_SHA256 {secret_hash} OP_EQUALVERIFY ' # noqa: E131 'OP_DUP OP_HASH160 {pkh0} ' 'OP_ELSE ' '{timeout} OP_CHECKLOCKTIMEVERIFY OP_DROP ' 'OP_DUP OP_HASH160 {pkh1} ' 'OP_ENDIF ' 'OP_EQUALVERIFY ' 'OP_CHECKSIG') # this spends via the HTLC secret revelation path # Needs (signature, pubkey, secret, TRUE) # IN THAT ORDER! htlc_stack_script_execute = '{sig} {pk} {secret} OP_1' # this spends via the timelocked refund path # Needs (signature, pubkey, FALSE serialized_redeem_script) # IN THAT ORDER! htlc_stack_script_refund = '{sig} {pk} OP_0' # Worst secret in the world :D secret = '32' * 32
def test_cashaddr_from_output_script(self): riemann.select_network('bitcoin_cash_main') self.assertEqual(addr.from_output_script(helpers.PKH_0_OUTPUT_SCRIPT), helpers.P2PKH_0_CASHADDR) self.assertEqual(addr.from_output_script(helpers.OP_IF_OUTPUT_SCRIPT), helpers.OP_IF_CASHADDR)
def test_get_current_network_name(self): for n in networks.SUPPORTED: riemann.select_network(n) self.assertEqual(riemann.get_current_network_name(), n)
def tearDown(self): riemann.select_network('bitcoin_main')
def setUp(self): riemann.select_network('decred_main')
def test_select_network(self): for n in networks.SUPPORTED: riemann.select_network(n) self.assertIs(riemann.network, networks.SUPPORTED[n])
def test_make_decred_outpoint(self): riemann.select_network('decred_main') self.assertEqual( tb.make_outpoint(tx_id_le=helpers.DCR['ser']['ins'][0]['hash'], index=0, tree=0), helpers.DCR['ser']['ins'][0]['outpoint'])