def test_disconnect_peer(self):
peers = self.client('faucet').list_peers()
if peers:
logger.warning('Already connected, lets disconnect')
for peer in peers:
logger.debug(f'Disconnecting: {peer}')
# TODO all active channels with the peer need to be closed first
try:
self.client('faucet').disconnect_from_peer(peer)
except Exception as e:
if str(e.details()).endswith(
'all active channels with the peer need to be closed first'
):
self.client('faucet').close_peer_channels(peer=peer,
force=True)
rpc_connection = AuthServiceProxy(self.rpc_host)
blocks = rpc_connection.generate(10)
# try one more time
time.sleep(1)
self.test_disconnect_peer()
break
else:
raise AssertionError(e.details())
self.assertEqual([], self.client('faucet').list_peers())
else:
try:
self.connect_to_peer('faucet', 'alice')
self.test_disconnect_peer()
except Exception as e:
self.fail(e)
time.sleep(1)
def test_open_channel(self):
try:
self.connect_to_peer('faucet', 'alice')
self.connect_to_peer('faucet', 'bob')
except Exception as e:
self.fail(e)
self.send_btc_to_node('alice', amount=100000000)
self.send_btc_to_node('bob', amount=100000000)
# alice and bob opens one wau funded channels with faucet
generate_blocks = self.open_channel('alice', 'faucet', 100000000)
generate_blocks = True if self.open_channel(
'bob', 'faucet', 100000000,
remote_funding=200000) else generate_blocks
# generate_blocks = True if self.open_channel('faucet', 'bob', 200000) else generate_blocks
# if generate_blocks:
# GENERATE 10 blocks, to confirm channel
rpc_connection = AuthServiceProxy(self.rpc_host)
blocks = rpc_connection.generate(10)
self.assertGreaterEqual(len(blocks), 10)
time.sleep(1)
try:
channels = self.client('alice').list_channels()
self.assertIsNotNone(channels.channels)
self.assertTrue(
self.client('faucet').identity_pubkey in set(
ch.remote_pubkey for ch in channels.channels))
except Exception as e:
self.fail(e)
try:
channels = self.client('bob').list_channels()
self.assertIsNotNone(channels.channels)
self.assertTrue(
self.client('faucet').identity_pubkey in set(
ch.remote_pubkey for ch in channels.channels))
except Exception as e:
self.fail(e)
def send_btc_to_node(self, node, amount=100000000):
try:
balance = self.client(node).wallet_balance()
logger.info(balance)
if not balance.get('confirmed_balance') or balance.get(
'confirmed_balance') < amount:
faucet_address = self.client(node).address().address
# send bitcoin to faucet_address
logger.debug(amount / 100000000 -
balance.get('confirmed_balance') / 100000000)
rpc_connection = AuthServiceProxy(self.rpc_host)
txid = rpc_connection.sendtoaddress(
faucet_address,
float("{0:.8f}".format(amount / 100000000 -
balance.get('confirmed_balance') /
100000000)))
blocks = rpc_connection.generate(10)
self.send_btc_to_node(node)
except Exception as e:
self.fail(e)
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import ssl
import logging
logging.basicConfig()
logging.getLogger("BitcoinRPC").setLevel(logging.DEBUG)
rpc_connection = AuthServiceProxy("https://%s:%[email protected]:8334" %
('dev', 'abc123'),
ssl_context=ssl._create_unverified_context())
info = rpc_connection.getinfo()
print(info)
blocks = rpc_connection.generate(400)
print(blocks)
info = rpc_connection.getinfo()
print(info)
def generate_initial_blocks():
pass
class BitcoinClient(object):
"""Bitcoin client class"""
# Handler for Bitcoin connection
connection = None
network_info = None
blockchain_info = None
wallet_info = None
def __init__(self):
self.user = os.environ["BITCOIN_USER"]
self.password = os.environ["BITCOIN_PASSWORD"]
self.host = os.environ["BITCOIN_HOST"]
self.port = int(os.environ["BITCOIN_PORT"])
self.connection = AuthServiceProxy(
"http://%s:%s@%s:%i" %
(self.user, self.password, self.host, self.port))
def info(self):
# Use following links for reference:
# https://chainquery.com/bitcoin-api/getblockchaininfo
# https://chainquery.com/bitcoin-api/getnetworkinfo
# https://chainquery.com/bitcoin-api/getwalletinfo
self.blockchain_info = self.connection.getblockchaininfo()
self.network_info = self.connection.getnetworkinfo()
self.wallet_info = self.connection.getwalletinfo()
accounts = []
for acc in self.connection.listaccounts(0):
if len(acc) > 0:
accounts.append(acc)
# new_address = self.new_address()
# new_address_valid = self.validate_address(new_address)
# new_address_pk = self.get_private_key(new_address)
# New address: "miC9oPat2xrtDstticmrw2YM7UUN9A6jcn"
# New address private key: "cNci511KkyyU8GqMdZVxv1NxMbUMKqjo75PAQNdBFGgzbD7W8gZm"
# valid_bitcoin_address = '134dV6U7gQ6wCFbfHUz2CMh6Dth72oGpgH'
# addr = Address(self, valid_bitcoin_address)
data_hash = {
"blocks": int(self.blockchain_info["blocks"]),
"headers": int(self.blockchain_info["headers"]),
"bestblockhash": self.blockchain_info["bestblockhash"],
"difficulty": float(self.blockchain_info["difficulty"]),
"accounts": accounts,
"account_addresses": self.connection.getaddressesbyaccount(""),
# "new_address": str(self.new_account('Trololo')),
# "new_address": new_address,
# "new_address_valid": new_address_valid,
# "new_address_pk": new_address_pk,
# "valid_address_balance": addr.balance(),
}
return data_hash
def balance(self):
"""Overall balance of current wallet
Returns:
(int) balance in satoshis
"""
balance = float(self.connection.getbalance())
# return balance
return int(balance * SATOSHI)
def new_address(self):
"""Generate new address"""
return self.connection.getnewaddress()
def get_private_key(self, address):
"""Fetch private key of specific address owned by you.
Keyword arguments:
address -- address (public key) to fetch from
"""
return self.connection.dumpprivkey(address)
def validate_address(self, address):
"""Check that address is valid on Blockchain.
Keyword arguments:
address -- address (public key) to validate
"""
result = self.connection.validateaddress(address)
if "isvalid" in result:
return result["isvalid"]
return False
def new_account(self, name):
"""Generate new account and address.
Keyword arguments:
name -- name of the account, not stored in the blockchain
"""
return self.connection.getnewaddress(name)
def generate_blocks(self, amount):
"""Generate some blocks. Availabe only in Regtest mode.
Keyword arguments:
amount -- number of blocks to generate
"""
return self.connection.generate(amount)
def lock_wallet(self):
"""Lock current wallet."""
return self.connection.walletlock()
def unlock_wallet(self, passphrase=None, seconds=60):
"""Unlock current wallet with a passphase.
Keyword arguments:
passphrase -- the passphrase that unlocks the wallet
seconds -- the number of seconds after which the decryption key will be automatically deleted from memory
"""
if not passphrase:
passphrase = os.environ["BITCOIN_WALLET_PASSPHRASE"]
return self.connection.walletlock(passphrase, seconds)
def change_wallet_passphrase(self,
old_passphrase=None,
new_passphrase=None):
"""Set passphrase for current wallet.
Keyword arguments:
old_passphrase -- old passphrase that unlocks the wallet
new_passphrase -- new passphrase that unlocks the wallet
"""
if not old_passphrase:
old_passphrase = ''
if not new_passphrase:
new_passphrase = os.environ["BITCOIN_WALLET_PASSPHRASE"]
return self.connection.walletpassphrasechange(old_passphrase,
new_passphrase)
def send(self, from_addr, to_addr, amount):
"""Send funds from address to address. Returns transaction ID.
Keyword arguments:
from_addr -- address (public key) we're sending funds from
to_addr -- address (public key) we're sending funds to
amount -- (float) amount of bitcoins to send
"""
return self.connection.sendfrom(from_addr, to_addr, amount)
def generate_valid_source_tx(
s: protocol.State,
con: AuthServiceProxy,
max_tx: int
) -> None:
# Transmit enough funds to addresses so that we won't need
# to use coinbase transactions.
# There are at most MAX many transactions in one step. Hence,
# we need at most that many different addresses. (We can always
# use the change addresses because our transactions have nearly
# no costs)
num_addr = max_tx // 10 # We want at most 50 advertisements to use the
# same address
s.source_tx = []
start = con.getblockcount() + 1
con.generate(num_addr + 101)
top = con.getblockcount()
interval = range(start, top - 100)
block_hashes = con.batch_([["getblockhash", h] for h in interval])
blocks = con.batch_([["getblock", ha, 2] for ha in block_hashes])
del block_hashes
txs = [block['tx'][0] for block in blocks]
del blocks
sent_txs = []
i = 0
value = -1
txid = -1
n = -1
for tx in txs:
for out in tx['vout']:
if out['scriptPubKey']['type'] == 'pubkey':
# The pubkey transactions are coinbase transactions because
value = out['value']
txid = tx['txid']
n = out['n']
if value == -1 or txid == -1 or n == -1:
raise RuntimeError("No coinbase transaction found.")
addr = con.getnewaddress()
sent_value = float(value) / 2 # create two addresses per transaction
raw_tx = con.createrawtransaction([{'txid': txid, 'vout': n}], {
addr: sent_value}) # The - is for the fees
funded_tx = con.fundrawtransaction(raw_tx)
signed_tx = con.signrawtransactionwithwallet(funded_tx["hex"])
if signed_tx["complete"] is False:
raise RuntimeError(
"bitcoind could not sign the transaction. (During "
"Initialization)")
txid = con.sendrawtransaction(signed_tx["hex"])
sent_txs.append(txid)
i += 1
# Create a block each 100 transactions
if i == 100:
con.generate(1)
i = 0
con.generate(1)
txs = con.batch_([['getrawtransaction', txid, 1] for txid in sent_txs])
for tx in txs:
for out in tx['vout']:
vout = out['n']
s.source_tx.append(opreturn.Transaction(tx['txid'], vout))
c = 0
for utxo in s.source_tx:
if not protocol.is_valid_utxo(utxo):
c += 1
print("Found %d invalid utxos." % c)
hash_of_reconstructed_animecoin_zstd_uncompressed_data = get_sha256_hash_of_input_data_func(
reconstructed_animecoin_zstd_uncompressed_data)
assert (hash_of_reconstructed_animecoin_zstd_uncompressed_data ==
reconstructed_uncompressed_data_file_hash)
print('Successfully reconstructed and decompressed data!')
return reconstructed_animecoin_zstd_uncompressed_data
if 0: #Demo:
if 0: #Start up bitcoind using the regtest network and generate some coins to use:
rpc_auth_command_string = '-rpcuser='******' -rpcpassword='******'bitcoind.exe ' + rpc_auth_command_string + ' -regtest -server -addresstype=legacy' #Without -addresstype=legacy the current bitcoind will default to using segwit addresses, which suck (you can't sign messages with them)
proc = subprocess.Popen(bitcoind_launch_string, shell=True)
sleep(5)
rpc_connection = AuthServiceProxy(rpc_connection_string)
block_generation_output = rpc_connection.generate(
101) #Generate some coins to work with
path_to_animecoin_html_ticket_file = 'C:\\animecoin\\art_folders_to_encode\\Carlo_Angelo__Felipe_Number_02\\artwork_metadata_ticket__2018_05_27__23_42_33_964953.html'
with open(path_to_animecoin_html_ticket_file, 'r') as f:
animecoin_ticket_html_string = f.read()
use_generate_new_compression_dictionary = 1
if use_generate_new_compression_dictionary:
animecoin_zstd_compression_dictionary = generate_zstd_dictionary_from_folder_path_and_file_matching_string_func(
path_where_animecoin_html_ticket_templates_are_stored,
'*ticket*.html')
animecoin_zstd_compression_dictionary_raw_data = animecoin_zstd_compression_dictionary.as_bytes(
)
compression_dictionary_hash = get_sha256_hash_of_input_data_func(
animecoin_zstd_compression_dictionary_raw_data)
with open(
working_dir = my_path + "/../state" # Path to binary files
# Create bin folder if it does not exist:
try:
os.mkdir(working_dir)
except FileExistsError:
pass
# Connect to Deamon
con = AuthServiceProxy("http://%s:%[email protected]:%s" %
(State.RPC_USER, State.RPC_PASSWORD, port))
peers = [] # List of peers, each with valid credit
users = [] # List of users, each with valid credit
for i in range(0, NUM_PEERS + 1):
b = con.generate(1)
tx = con.getblock(b[0])['tx'][0]
(pri, pub) = generate_key_pair()
p = protocol.Peer(ip_address=ipaddress.IPv4Address(get_random_bytes(4)),
port=int(random.randint(3000, 4000)),
public_key=pub.to_string(),
private_key=pri.to_string(),
cont_tx=opreturn.Transaction(tx, 0),
service=bytes([0x01, 0x00]))
peers.append(p)
for i in range(0, NUM_USERS + 1):
b = con.generate(1)
tx = con.getblock(b[0])['tx'][0]
users.append({'txs': [opreturn.Transaction(tx, 0)]})
sys.exit()
# Fix problem with wrong format of IPs
for p in peers:
if type(p.ip_address) is str:
p.ip_address = ipaddress.ip_address(p.ip_address)
# Define a list of tx to take the money from
generate_valid_source_tx(s, con, MAX)
# Determine size of coinbase TXs
# Re-Connect to Daemon (to avoid overburdening bitcoind)
con = AuthServiceProxy(
"http://%s:%[email protected]:%s" %
(State.RPC_USER, State.RPC_PASSWORD, PORT), )
con.generate(1)
bh = con.getblockhash(con.getblockcount())
json = con.getblock(bh, 2)
coinbase_sizes = [183]
coinbase_avg_sizes = [156]
for tx in json['tx']:
coinbase_sizes.append(tx['size'])
coinbase_avg_sizes.append(tx['vsize'])
print("Coinbase transactions have sizes {} and stripped sizes {}.".format(
coinbase_sizes, coinbase_avg_sizes))
filename = get_filename(NUM_PEERS, (MIN, MAX, STEP), REPS)
file_path = get_size_eval_path() + '/' + filename
error_count = 0
with open(file_path, 'w') as fd:
fd.write("------------------------HEADER------------------------\n")
def add_confirmations(confirmations):
if not confirmations in (1, 2, 3, 4, 5, 6):
return {'error': 'confirmation value supplied not in interval from 1 through 6'}
bitcoind=AuthServiceProxy("http://%s:%[email protected]:8332" % (config.rpc_user, config.rpc_password), timeout=600)
blocks=bitcoind.generate(confirmations)
return {'result': blocks}
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://*****:*****@172.17.0.3:18332")
# best_block_hash = rpc_connection.getbestblockhash()
# print(rpc_connection.getblock(best_block_hash))
for x in range(5):
start = time.time()
#result = rpc_connection.generate(1)
result = rpc_connection.getbestblockhash()
# result = rpc_connection.getblocktemplate()
end = time.time()
print(rpc_connection.generate(1))
print(end-start)
exit(1)
# batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips:
commands = [ [ "getblockhash", height] for height in range(100) ]
block_hashes = rpc_connection.batch_(commands)
blocks = rpc_connection.batch_([ [ "getblock", h ] for h in block_hashes ])
block_times = [ block["time"] for block in blocks ]
print(block_times)
from bitcoinrpc.authproxy import AuthServiceProxy
access = AuthServiceProxy("http://*****:*****@172.17.0.3:18332")
#Genere 2000 blocks
access.generate(2000)
from bitcoinrpc.authproxy import AuthServiceProxy
#Génère un block depuis chaque noeud
for x in range(1, 4):
access = AuthServiceProxy("http://*****:*****@172.17.0."+str(x+1)+":18332")
access.generate(1)
bts = round(10*random.random(),8)
print('Payment %d: %.8f BTCs' %(i+1, bts))
amount += bts
print(rpc_con.sendtoaddress(address, bts))
print('Total amount sent to P2SH address: %.8f BTCs (%d TXs)' %(amount, num_txs))
# Mine 1 block in order the transactions to take effect
rpc_con.generate(1)
# Lets send some BTs to P2SH address
# I assume that blockchain is initially empty, so i have first to create
# at least 101 blocks to receive the first mining fees, in order to be able
# to make the payment transactions.
print('\nMining first 101 blocks')
rpc_con.generate(101)
# Create random # of payments to P2SH address
send_bts_to_address(p2sh_addr)
# Check mempool for pending transactions and P2SH address for total received amount
print('\nPending transactions in mempool: %d' %len(rpc_con.getrawmempool()))
print('\nTotal amount received by P2SH address: %.8f BTCs' %rpc_con.getreceivedbyaddress(p2sh_addr))
# ***** Check if the P2SH address has any UTXOs to get funds from
def find_UTXOs_of_address(address):
'''
This method scans all UTXOs of all addresses in the wallet and returns only
