class XP_RPC():
def __init__(self):
self.connection = AuthServiceProxy(
settings.RPC_URL % (settings.rpc_user, settings.rpc_password))
self.tax = 1.0
def get_address(self, name):
# commands = [["getaddressesbyaccount", name]]
address = self.connection.getaddressesbyaccount(name)
if address:
address = address[0]
else:
address = self.connection.getaccountaddress(name)
return address
def show_balance(self, name):
address = self.connection.getaddressesbyaccount(name)
if address:
balance = self.connection.getbalance(name)
else:
address = self.connection.getaccountaddress(name)
balance = self.connection.getbalance(name)
print(balance)
return balance
def move_balance(self, name, to_name, amount):
address = self.connection.getaddressesbyaccount(name)
to_address = self.connection.getaddressesbyaccount(to_name)
if address and to_address:
# req = self.connection.move(name, to_name, amount)
req = self.connection.move(name, to_name, amount)
elif address:
self.connection.getaccountaddress(to_name)
req = self.connection.move(name, to_name, amount)
else:
req = "Error"
return req
def send_from(self, name, address, amount):
txid = self.connection.sendfrom(name, address, amount)
tx = self.connection.gettransaction(txid)
if tx:
fee = tx["fee"]
else:
fee = 0
self.move_balance(name, "taxpot", float(fee) + self.tax)
return txid
def validateaddress(self, address):
return self.connection.validateaddress(address)['isvalid']
def main():
bitcoin = AuthServiceProxy("http://{}:{}@127.0.0.1:{}".format(
RPCUSER, RPCPASSWORD, RPCPORT))
address = ADDRESS
if address is None:
address = bitcoin.getaddressesbyaccount("")[0]
print("Using wallet address: ", address)
parent_txid = "NULL"
subprotocols = [None, gen_media, gen_pastebin, gen_randomdata]
# Create nodes...
for i in range(NUM_NODES_TO_CREATE):
node = create_node(address, parent_txid)
# Add subprotocols to node
for _ in range(5):
subprotocol = secrets.choice(subprotocols)
if subprotocol is not None:
node['subprotocols'].append(subprotocol())
# Create OP_RETURN data
data = b'meta' + encode_function(ENCODING)(node)
assert (len(data) < 100000) # sanity check for op_return max limit
data_hex = data.hex()
# bitcoin rpc commands to create and fund tx with metanet data in OP_RETURN
rawtx = bitcoin.createrawtransaction([], {'data': data_hex})
result = bitcoin.fundrawtransaction(rawtx, {'changeAddress': address})
rawtx = result['hex']
result = bitcoin.signrawtransaction(rawtx)
assert (result['complete'])
signedtx = result['hex']
txid = bitcoin.sendrawtransaction(signedtx)
# Prepare for next iteration
parent_txid = txid
print("[Node {}]: https://test.whatsonchain.com/tx/{}".format(i, txid))
class BTCRPCCall(object):
def __init__(self, wallet="receive", currency="btc"):
yml_config_reader = ConfigFileReader()
url = yml_config_reader.get_rpc_server(currency=currency,
wallet=wallet)
self.access = AuthServiceProxy(url)
def do_getinfo(self):
return self.access.getinfo()
def do_get_new_address(self):
return self.access.getnewaddress()
def do_set_account(self, address, account):
return self.access.setaccount(address, account)
def do_get_transaction(self, txid):
try:
return self.access.gettransaction(txid)
except RuntimeError:
# return simplejson.dumps ({u'error' : u'txid is not valid'})
return None
def do_list_transactions(self, account, count=10, from_index=0):
try:
return self.access.listtransactions(account, count, from_index)
except RuntimeError:
print "calling failure"
def do_get_transaction(self, tx_id):
try:
return self.access.gettransaction(tx_id)
except RuntimeError:
#return simplejson.dumps ({u'error' : u'txid is not valid'})
return None
def amount_received_by_address(self, address="", confirms=0):
return self.access.getreceivedbyaddress(address, confirms)
def do_validate_address(self, address=""):
return self.access.validateaddress(address)
def list_transactions(self, account="", count=10, from_index=0):
return self.access.listtransactions(account, count, from_index)
def send_from(self, from_account="", to_address="", amount=0, minconf=1):
return self.access.sendfrom(from_account, to_address, amount, minconf)
def get_received_amount_by_account(self, account="", minconf=1):
return self.access.getreceivedbyaccount(account, minconf)
def get_balance(self, account="", minconf=1):
return self.access.getbalance(account, minconf)
def get_wallet_balance(self):
return self.access.getbalance()
def move(self, from_account="", to_account="", amount=0, minconf=1):
return self.access.move(from_account, to_account, amount, minconf)
def list_accounts(self, confirmations=1):
return self.access.listaccounts(confirmations)
def list_received_by_address(self, confirmations=1, include_empty=False):
return self.access.listreceivedbyaddress(confirmations, include_empty)
def get_addresses_by_account(self, account):
return self.access.getaddressesbyaccount(account)
def set_tx_fee(self, amount):
return self.access.settxfee(amount)
def send_to_address(self, address, amount, subtractfeefromamount=True):
return self.access.sendtoaddress(address, amount, "", "",
subtractfeefromamount)
# amount is type of dictionary
def send_many(self, from_account="", minconf=1, **amounts):
log.info("From account: %s", from_account)
log.info("To accounts: %s", json.dumps(amounts))
amounts_string = json.dumps(amounts['amounts'])
amounts_object = json.loads(amounts_string)
try:
return True, self.access.sendmany(from_account, amounts_object,
minconf)
except JSONRPCException as ex:
return False, ex
except socket.error as e:
return False, e
class BtcWallet():
"""btc钱包"""
BTC_BLOCK_API = 'https://blockchain.info/'
def __init__(self, app=None, consul_client=None):
if app and consul_client:
self.init_consul(app, consul_client)
def init_consul(self, app, consul_client):
try:
rpc_user = app.config.get('CONFIG_BITCOIND_RPC_USER')
rpc_pwd = app.config.get('CONFIG_BITCOIND_RPC_PASSWORD')
wallet_passphrase = app.config.get('CONFIG_BITCOIND_WALLET_PASSWORD')
self.ipport = consul_client.getRandomOneAvailableServiceIpPort(ConsulServiceName.BTC_CLI)
# s = "http://%s:%s@" % (self.user, self.pwd) + self.ipport
# print(s)
self.bitcoin_cli = AuthServiceProxy(
"http://%s:%s@" % (rpc_user, rpc_pwd) + self.ipport, timeout=10)
print("Succeed to connect to the BTC node")
except Exception as e:
print(str(e))
print("Failed to connect to the BTC node")
# 是否连接BTC节点
def is_connected(self):
try:
if self.bitcoin_cli.getwalletinfo().get('walletversion'):
return True
return False
except Exception as e:
print(str(e))
print("Failed to connect to the BTC node")
# 节点是否同步
def is_sync(self):
ret = self.bitcoin_cli.getblockchaininfo()
if ret.get('blocks') != ret.get("headers"):
return False
else:
return True
# btc地址是否有效
def is_valid_address(self, coin_address):
if coin_address is None or coin_address == '':
return False
else:
ret = self.bitcoin_cli.validateaddress(coin_address).get('isvalid')
print('账户检查结果:', ret)
return ret
# return self.bitcoin_cli.validateaddress(coin_address).get('isvalid')
# 获取账户余额, 默认经过6个区块确认
def get_balance(self, coin_address):
transaction_lists = self.bitcoin_cli.listunspent(1, 99999999, [coin_address])
print(transaction_lists)
current_amount = 0
for transaction_list in transaction_lists:
amount = transaction_list.get('amount')
amount = float(amount)
current_amount += amount
return current_amount
def get_balance_by_account(self, account):
try:
ret = self.bitcoin_cli.getbalance(account)
return ret
except Exception as e:
logging.error('get balance error:{}'.format(str(e)))
return None
def estimate_fee(self):
try:
fee = self.bitcoin_cli.estimatefee(6)
return fee
except Exception as e:
logging.error('get fee error:{}'.format(str(e)))
return None
def create_account(self, stellar_account):
# private = random_key()
# address = pubtoaddr(privtopub(private))
# print(address, private)
# return address, private
address = self.bitcoin_cli.getnewaddress(stellar_account)
private_key = self.bitcoin_cli.dumpprivkey(address)
return address, private_key
def get_block_num(self):
"""获取最新区块数"""
try:
block_num = self.bitcoin_cli.getblockcount()
return block_num
except Exception as e:
logging.error('Get btc node block number error:{}'.format(str(e)))
return None
def get_chain_info(self):
ret = self.bitcoin_cli.getblockchaininfo()
return ret
def get_block_info(self, block_num):
"""获取区块的详细信息"""
param = "block-height/{}?format=json".format(block_num)
api_url = self.BTC_BLOCK_API + param
# print(api_url)
blocks = requests.get(api_url, timeout=500).json()
# print(type(blocks))
return blocks
# 链外转帐,普通交易
def payment(self, btc_base_account, address_to, amount):
try:
txid = self.bitcoin_cli.sendfrom(btc_base_account, address_to, amount)
return True, txid
except Exception as e:
logging.error('btc payment error:{}'.format(str(e)))
return False, str(e)
def hash_get_detail(self, tx_id):
"""
Arguments:
1. "txid" (string, required) The transaction id
"""
# 根据txid获取确认链外交易信息
ret = self.bitcoin_cli.gettransaction(tx_id)
abandoned = ret.get("details")[0].get("abandoned") # 获取abandon信息
confirmation_num = ret.get('confirmations') # 获取确认数
# 如果确认数小于1，则未确认
if confirmation_num < 1:
msg = dict(confirm=str(ret))
# msg = ret.get("details")[0]
return False, False, msg, None
# 如果确认数大于1，则确认
else:
msg = dict(confirm=str(ret))
# msg = ret
fee = abs(ret.get("fee"))
if abandoned:
return True, False, msg, None
else:
return True, True, msg, fee
def raw_payment(self, address_from, address_to, collect_amount):
inputs = []
# 获取地址余额信息
try:
unspend_lists = self.bitcoin_cli.listunspent(1, 9999999, [address_from])
for unspend_list in unspend_lists:
# if unspend_list.get('amount') <= 0:
# continue
# else:
txid = unspend_list.get('txid')
vout = unspend_list.get('vout')
inputs.append({'txid': txid, 'vout': vout})
outputs = {address_to: round(collect_amount, 8)}
# 交易建立和签名时不用连接比特币网络,只有在执行交易时才需要将交易发送到网络
# 创建裸交易
transaction_hash = self.bitcoin_cli.createrawtransaction(inputs, outputs)
# 使用私钥签名,获取16进制信息
hex = self.bitcoin_cli.signrawtransaction(transaction_hash).get('hex')
# 广播到p2p网络,返回交易哈希
trading_hash = self.bitcoin_cli.sendrawtransaction(hex, False)
return True, trading_hash, ''
except Exception as e:
print(e)
return None, None, ''
def btc_transaction_record(self, block_num):
# 获取某一区块信息
block_info = self.get_block_info(block_num)
blocks = block_info.get('blocks')
txs = blocks[0].get('tx')
records = []
for tx in txs:
outs = tx.get('out')
hash = tx.get('hash')
inputs = tx.get('inputs')
p_out = inputs[0].get('prev_out')
if not p_out:
continue
else:
addr_from = p_out.get('addr')
for out in outs:
re = []
addr_to = out.get('addr')
value = out.get('value') / (10 ** 8)
# addr_to与User表中绑定的地址进行对比，如果有，则说明此address_to有冲币记录
user = User.address_query_user('BTC', addr_to)
if not user:
continue
else:
re.append(addr_from)
re.append(addr_to)
re.append(value)
re.append(hash)
records.append(re)
return records
def get_accounts(self, addr):
try:
ad = self.bitcoin_cli.getaccount(addr)
return ad
except Exception as e:
# logging.error('get btc_account error:{}'.format(str(e)))
return None
def get_address_byaccount(self, account):
re = self.bitcoin_cli.getaddressesbyaccount(account)
return re
def test1(self):
transaction_list = self.bitcoin_cli.listaccounts()
# transaction_list = self.bitcoin_cli.getwalletinfo()
print(transaction_list)
addr = raw_input("Enter a Bitcoin address: ")
print access.getaccount(addr)
except:
print "\n---An error occurred---\n"
elif cmd == "getaccountaddress":
try:
acct = raw_input("Enter an account name: ")
print access.getaccountaddress(acct)
except:
print "\n---An error occurred---\n"
elif cmd == "getaddressesbyaccount":
try:
acct = raw_input("Enter an account name: ")
print access.getaddressesbyaccount(acct)
except:
print "\n---An error occurred---\n"
elif cmd == "getbalance":
try:
acct = raw_input("Enter an account (optional): ")
mc = raw_input("Minimum confirmations (optional): ")
try:
print access.getbalance(acct, mc)
except:
print access.getbalance()
except:
print "\n---An error occurred---\n"
elif cmd == "getbestblockhash":
print access.getbestblockhash()
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)
async def on_ready():
# Randomize start time, do not remove or you will be rate limited!
sleep_time = random.randint(1, 299)
print("Sleeping for %s seconds..." % sleep_time)
await asyncio.sleep(sleep_time)
headers = {
'x-api-key': FAT_PANDA_CLUB_API_KEY,
'content-type': "application/json",
'user-agent': "panda-stake-node-%s" % CURRENCY_TICKER.lower()
}
# On failure check VPS is able to access target node and RPC credentials are correct
connection = AuthServiceProxy("http://%s:%s@%s:%s" % \
( STAKE_NODE_RPC_USERNAME, STAKE_NODE_RPC_PASSWORD, STAKE_NODE_HOST, STAKE_NODE_PORT) , timeout=10)
# Customize based on individual daemon
try:
current_balance = connection.getbalance()
recent_transactions = connection.listtransactions("*", 100, 0)
base_address = connection.getaddressesbyaccount("")
if len(base_address) == 0:
base_address = connection.getnewaddress("")
# base_address = connect.getaccountaddress("")
except Exception as exception:
print("Could not connect to daemon: %s" % exception)
await client.close()
sys.exit(exception)
# Submit deposits to panda-bot
print("Submitting %s tx" % len(recent_transactions))
url = "https://api.fatpanda.club/stake/%s" % CURRENCY_TICKER.lower()
payload = {
"op": "stakes",
"transactions": recent_transactions,
"timestamp": int(time.time()),
"balance": float(current_balance),
"address": base_address[0]
}
response = requests.request("POST", url, headers=headers, json=payload)
if response.status_code == 200:
print(response.json())
elif response.status_code == 429:
await client.close()
sys.exit(
"Rate limited! Please decrease your job frequency and wait a while."
)
else:
await client.close()
sys.exit(response.json()['message'])
# Process operations from panda-bot
response = requests.request("GET", url, headers=headers)
if response.status_code != 200:
await client.close()
sys.exit(response.json()['message'])
elif response.status_code == 429:
await client.close()
sys.exit(
"Rate limited! Please decrease your job frequency and wait a while."
)
else:
response_json = response.json()
unstakes = response.json()['unstakes']
panda_audit_channel = client.get_channel(PANDA_AUDIT_CHANNEL)
project_audit_channel = client.get_channel(
response.json()['private_audit_channel'])
for op in unstakes:
# Make sure audit messages are correct, for both panda and project
### DO NOT CHANGE THIS! This is under project accountability
project_audit_message = await project_audit_channel.fetch_message(
op['private_audit_id'])
project_audit_validation = re.match(
AUDIT_MESSAGE_REGEX, project_audit_message.content.strip())
panda_audit_message = await panda_audit_channel.fetch_message(
op['panda_audit_id'])
panda_audit_validation = re.match(
AUDIT_MESSAGE_REGEX, panda_audit_message.content.strip())
if not project_audit_validation:
unstake_message = "< %s-%s > project audit validation failed!" % (
op['currency'], op['reference'])
elif not project_audit_validation.group(1).lower() == "%s-%s" % (
CURRENCY_TICKER.lower(), op['reference'].lower()):
unstake_message = "< %s-%s > project ticker validation failed!" % (
op['currency'], op['reference'])
elif not isclose(float(project_audit_validation.group(2)),
op['amount'] + op['fee'],
abs_tol=1e-5):
unstake_message = "< %s-%s > project amount validation failed!\n%0.4f vs %0.4f + %0.4f" % (
op['currency'], op['reference'],
float(project_audit_validation.group(2)), op['amount'],
op['fee'])
elif not project_audit_validation.group(
3).lower() == op['to_address'].lower():
unstake_message = "< %s-%s > project address validation failed!" % (
op['currency'], op['reference'])
elif not panda_audit_validation:
unstake_message = "< %s-%s > panda audit validation failed!" % (
op['currency'], op['reference'])
elif not panda_audit_validation.group(1).lower() == "%s-%s" % (
CURRENCY_TICKER.lower(), op['reference'].lower()):
unstake_message = "< %s-%s > panda ticker validation failed!" % (
op['currency'], op['reference'])
elif not isclose(float(panda_audit_validation.group(2)),
op['amount'] + op['fee'],
abs_tol=1e-5):
unstake_message = "< %s-%s > panda amount validation failed!\n%0.4f vs %0.4f + %0.4f" % (
op['currency'], op['reference'],
float(panda_audit_validation.group(2)), op['amount'],
op['fee'])
elif not panda_audit_validation.group(
3).lower() == op['to_address'].lower():
unstake_message = "< %s-%s > panda address validation failed!" % (
op['currency'], op['reference'])
else:
### ALL CHECKS PERFORMED TO ENSURE AUDIT MESSAGES ARE VALID, ELSE TX IS SKIPPED and NOT PROCESSED
try:
txid = connection.sendtoaddress(op['to_address'],
op['amount'])
unstake_message = "< %s-%s > unstake sent: %s" % (
op['currency'], op['reference'], txid)
except Exception as exception:
txid = 'failed'
unstake_message = "< %s-%s > unstake failed! %s" % (
op['currency'], op['reference'], exception)
try:
await panda_audit_channel.send(content=unstake_message)
await project_audit_channel.send(content=unstake_message)
except Exception as exception:
print("Could not send unstake audit messages due to: %s" %
exception)
op['txid'] = txid
response = requests.request("POST", url, headers=headers, json=op)
await client.close()
class BTCRPCCall(object):
def __init__(self, wallet="receive", currency="btc"):
yml_config_reader = ConfigFileReader()
url = yml_config_reader.get_rpc_server(currency=currency, wallet=wallet)
self.access = AuthServiceProxy(url)
def do_getinfo(self):
return self.access.getinfo()
def do_get_new_address(self):
return self.access.getnewaddress();
def do_set_account(self, address, account):
return self.access.setaccount(address, account)
def do_get_transaction(self, txid):
try:
return self.access.gettransaction(txid)
except RuntimeError:
# return simplejson.dumps ({u'error' : u'txid is not valid'})
return None
def do_list_transactions(self, account, count=10, from_index=0):
try:
return self.access.listtransactions(account, count, from_index)
except RuntimeError:
print("calling failure")
def do_get_transaction(self, tx_id):
try:
return self.access.gettransaction(tx_id)
except RuntimeError:
#return simplejson.dumps ({u'error' : u'txid is not valid'})
return None
def amount_received_by_address(self, address="", confirms=0):
return self.access.getreceivedbyaddress(address, confirms)
def do_validate_address(self, address=""):
return self.access.validateaddress(address)
def list_transactions(self, account="", count=10, from_index=0):
return self.access.listtransactions(account, count, from_index)
def send_from(self, from_account="", to_address="", amount=0, minconf=1):
return self.access.sendfrom(from_account, to_address, amount, minconf)
def get_received_amount_by_account(self, account="", minconf=1):
return self.access.getreceivedbyaccount(account, minconf)
def get_balance(self, account="", minconf=1):
return self.access.getbalance(account, minconf)
def get_wallet_balance(self):
return self.access.getbalance()
def move(self, from_account="", to_account="", amount=0, minconf=1):
return self.access.move(from_account, to_account, amount, minconf)
def list_accounts(self, confirmations=1):
return self.access.listaccounts(confirmations)
def list_received_by_address(self, confirmations=1, include_empty=False):
return self.access.listreceivedbyaddress(confirmations, include_empty)
def get_addresses_by_account(self, account):
return self.access.getaddressesbyaccount(account)
def set_tx_fee(self, amount):
return self.access.settxfee(amount)
def send_to_address(self, address, amount, subtractfeefromamount=True):
return self.access.sendtoaddress(address, amount, "", "", subtractfeefromamount)
# amount is type of dictionary
def send_many(self, from_account="", minconf=1, **amounts):
log.info("From account: %s", from_account)
log.info("To accounts: %s", json.dumps(amounts))
amounts_string = json.dumps(amounts['amounts'])
amounts_object = json.loads(amounts_string)
try:
return True, self.access.sendmany(from_account, amounts_object, minconf)
except JSONRPCException as ex:
return False, ex
except socket.error as e:
return False, e
"Ignoring unrecognised/invalid address ('{}')!\n".format(account))
continue
else:
logger.info("Account: {}".format(account))
if account.endswith(inputUser) == False:
logger.info("Skipping account. Doesn't belong to current user.\n")
# pprint("{} with balance {}".format(account, walletAccounts[account]));
continue
else:
nodeBalance = walletAccounts[account]
if nodeBalance > masternodeCollateral:
unspentList = rpcConnection.listunspent(
UNSPENT_MIN_CONF, UNSPENT_MAX_CONF,
rpcConnection.getaddressesbyaccount(account))
unspentBalance = Decimal(0)
if len(unspentList) > 0:
logger.info(
"Unspent list contains {} outs (incl. collateral). Calculating balance without collateral..."
.format(len(unspentList)))
# pprint(unspentList);
for otx in unspentList:
if otx['amount'] != masternodeCollateral:
logger.info(
"Unspent amount available: {} TFC (txid: {}).".
format(Decimal(otx['amount']), otx['txid']))
unspentBalance += Decimal(otx['amount'])
if account != holdingWalletName:
allUnspent.append(otx)
from pprint import pprint
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_user = '******'
rpc_password = '******'
rpc_host = '192.168.1.86:9332'
rpc_connection = AuthServiceProxy("http://{}:{}@{}".format(
rpc_user, rpc_password, rpc_host))
best_block_hash = rpc_connection.getbestblockhash()
accounts = rpc_connection.listaccounts()
address_with_name = {
name: rpc_connection.getaddressesbyaccount(name)
for name in accounts
}
print(accounts)
pprint(address_with_name)
dest_address = raw_input("Please input the address what you want to send ")
currency = raw_input("Please input the number of currency ") or 0
if currency == 0:
print("Currency couldn't be less or equal 0")
print("Currency are required more 0")
else:
rpc_connection.sendtoaddress(dest_address, int(currency))
def check_for_stake(self, RPC, log):
try:
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:%s"%(RPC['user'], RPC['pw'], RPC['port']))
# Check integrity of wallet before getting wallet info
check_wallet = rpc_connection.checkwallet()
except:
return "Unable to connect to wallet. Verify that it's running and your RPC settings are correct"
if 'wallet check passed' not in check_wallet:
log.info(check_wallet)
rpc_connection.repairwallet()
log.info("**Wallet was repaired**")
try:
txs = rpc_connection.listunspent(int(RPC['min_conf']), int(RPC['max_conf'])) # Only work with inputs that aren't mature
except:
return "Unable to run 'listunspent' over RPC, check that the wallet is still running"
input_sum = 0
utxo_size = Decimal(RPC['UTXO_size'])
input_tx = []
addresses_to_reuse = []
for each_tx in txs:
# Check out each existing transaction for desired size, sum up inputs that aren't
if each_tx['amount'] != utxo_size:
input_sum += each_tx['amount']
input_tx.append({"txid":each_tx['txid'],"vout":each_tx['vout']})
if 'account' in each_tx and each_tx['account'] == 'stake_script' and each_tx['address'] not in addresses_to_reuse:
# reuse input addresses for a new output if they have the label 'stake_script'
addresses_to_reuse.append(each_tx['address'])
if input_sum < utxo_size:
log.debug("DEBUG: Total coins: {0} is not enough to make a new packet of {1}".format(input_sum, utxo_size))
return "Total coins: {0} is not enough to make a new packet of {1} :DEBUG".format(input_sum, utxo_size)
# Reuse or make a new change and stake addresses
change_address = rpc_connection.getaddressesbyaccount("change")
if len(change_address) == 0:
change_address = [rpc_connection.getnewaddress("change")]
stake_addresses = rpc_connection.getaddressesbyaccount("stake_script")
for addr in stake_addresses:
amount = rpc_connection.getreceivedbyaddress(addr)
if amount == 0 and addr not in addresses_to_reuse:
# Only reuse addresses with the label stake_script and zero balance for safety
addresses_to_reuse.append(addr)
output_addresses = {}
number_of_splits = int(input_sum / utxo_size)
if len(addresses_to_reuse) < number_of_splits:
# Make as many new addresses as needed to split inputs into 'size' outputs
num_to_make = number_of_splits - len(addresses_to_reuse)
#if not arg.noconfirm:
# TODO implement
# print("About to make {0} new stake address(es), confirm".format(num_to_make))
# get_permission()
for _ in range(num_to_make):
addresses_to_reuse.append(rpc_connection.getnewaddress('stake_script'))
for _ in range(number_of_splits):
output_addresses[addresses_to_reuse.pop()] = utxo_size
#print(output_addresses)
assert(int(input_sum / utxo_size) == len(output_addresses)), "Not enough output addresses for number of UTXO splits!"
number_of_splits = len(output_addresses)
numbytes = 181 * len(input_tx) + 34* (number_of_splits+1) + 10
numKB = math.ceil(numbytes / 1000)
TX_FEE = Decimal(RPC['transaction_fee']) * numKB
log.debug("transaction fee is %d : %d bytes, fee multiple is %d"%(TX_FEE, numbytes,numKB))
change_amount = input_sum - (utxo_size * number_of_splits) - TX_FEE
output_addresses[change_address[0]] = change_amount
assert (change_amount > 0), "Change amount cannot be less than zero"
assert(change_amount + TX_FEE + (utxo_size*number_of_splits) == input_sum), "Coins will be lost if the total output != input"
log.debug("{0} Inputs {1}".format(len(input_tx),input_tx))
log.debug("{0} Outputs {1}".format(len(output_addresses), output_addresses))
log.info("{0} (Input total) = {2} ({1}_UTXO packets) + {3} (change) + {4} (fee)".format(input_sum,number_of_splits,utxo_size*number_of_splits,change_amount, TX_FEE))
# Generate, sign, and send the raw transaction
raw_tx = rpc_connection.createrawtransaction(input_tx, output_addresses)
signed_tx = rpc_connection.signrawtransaction(raw_tx)
if not signed_tx['complete']:
log.error("Signing failed of raw tranaction: {0}\nInputs: {1}\nOutputs: {2}".format(raw_tx, input_tx, output_addresses))
return "Signing of raw transaction did not complete successfully, make sure wallet is functioning properly"
#if not arg.noconfirm:
# print("About to send transaction, confirm")
# get_permission()
log.info("Attempting to send: {0} (Total inputs) = {2} ({1} new UTXO) + {3} (change) + {4} (fee)".format(input_sum,number_of_splits,utxo_size*number_of_splits,change_amount, TX_FEE))
try:
sent = rpc_connection.sendrawtransaction(signed_tx['hex'])
except Exception as e:
return "Sending transaction failed (Your wallet might need more time to update): {0}".format(str(e))
log.info("TX successful: transaction ID: {0}".format(sent))
now = datetime.datetime.now().strftime("%m-%d %H:%M")
return "{6} TX {5} successful: {0} (Total inputs) = {2} ({1} new UTXO) + {3} (change) + {4} (fee)".format(input_sum,number_of_splits,utxo_size*number_of_splits,change_amount, TX_FEE, sent, now)
class BTCRPCCall(object):
def __init__(self, wallet="receive", currency="btc"):
yml_config_reader = ConfigFileReader()
url = yml_config_reader.get_rpc_server(currency=currency, wallet=wallet)
self.access = AuthServiceProxy(url)
def do_getinfo(self):
return self.access.getinfo()
def do_get_new_address(self):
return self.access.getnewaddress();
def do_set_account(self, address, account):
return self.access.setaccount(address, account)
def do_get_transaction(self, txid):
try:
return self.access.gettransaction(txid)
except RuntimeError:
#return simplejson.dumps ({u'error' : u'txid is not valid'})
return None
def do_list_transactions(self, account, count=10, from_index=0):
try:
return self.access.listtransactions(account, count, from_index)
except RuntimeError:
print "calling failure"
def amount_received_by_address(self, address="", confirms=0):
return self.access.getreceivedbyaddress(address, confirms)
def do_validate_address(self, address=""):
return self.access.validateaddress(address)
def list_transactions(self, account="", count=10, from_index=0):
return self.access.listtransactions(account, count, from_index)
def send_from(self, from_account="", to_address="", amount=0, minconf=1):
return self.access.sendfrom(from_account, to_address, amount, minconf)
def get_received_amount_by_account(self, account="", minconf=1):
return self.access.getreceivedbyaccount(account, minconf)
def get_balance(self, account="", minconf=1):
return self.access.getbalance(account, minconf)
def get_wallet_balance(self):
return self.access.getbalance()
def move(self, from_account="", to_account="", amount=0, minconf=1):
return self.access.move(from_account, to_account, amount, minconf)
def list_accounts(self, confirmations=1):
return self.access.listaccounts(confirmations)
def list_received_by_address(self, confirmations=1, include_empty=False):
return self.access.listreceivedbyaddress(confirmations, include_empty)
def get_addresses_by_account(self, account):
return self.access.getaddressesbyaccount(account)
pubkeymike = "03985457b91195038af91c1c7b09c693e9a141681319b683c46871b2dbf1beb09d"
pubkeymine = "03133255e240ded2cd1d0b8fa5b659fd7713b74f6ea074f4a80e3cb1f0677df061"
multiaddress = "2NC9uL5Qcnt4awdTBi3jB6ADPVdvwP9iR8L"
redeemscript = "522103133255e240ded2cd1d0b8fa5b659fd7713b74f6ea074f4a80e3cb1f0677df0612103985457b91195038af91c1c7b09c693e9a141681319b683c46871b2dbf1beb09d52ae"
random = "mrTRKLaDF86gLdKnacjxkXJdRFS6S8poTY"
txtorandom = "bdad390ea15f1828466266a97d4f219ff2e64111a60cb204b30148b199260bd0"
random2 = "mmQDjcub4ozy7e7ET6Yx75MDcLQHdhofbU"
#print "NEW", bitcoin.getnewaddress("")
#print bitcoin.validateaddress(mine)
print ""
print "Addresses and priv keys in entire wallet"
addresses = bitcoin.getaddressesbyaccount("")
print addresses
for add in addresses:
if not add[0] == '2':
print bitcoin.dumpprivkey(add), add
## Create a multi-sig
print ""
print "Multi sig address"
adds = [pubkeymine, pubkeymike]
print "Addresses used", adds
multi = bitcoin.addmultisigaddress(2, adds)
multi = bitcoin.createmultisig(2, adds)
while True:
try:
round += 1
# check, how many new addresses coinhouse needs
address_gen_count = ch_api.how_many_addresses_are_needed()
# generate and get new addresses from bitcoind
new_addresses = list(btcd.getnewaddress(btc_account_incoming) for n in range(address_gen_count))
# register addresses in rails for showing them to end users
for address in new_addresses:
ch_api.give_new_addresses(address)
# check incoming addresses for balance (not yet verified).
# if there is enough btc on the account
# we transfer it to verifying. otherwise it is forced to await more btcs
incoming_addresses = btcd.getaddressesbyaccount(btc_account_incoming)
for address in incoming_addresses:
balance = btcd.getreceivedbyaddress(address, 0)
if balance > 0:
is_paid_enough = ch_api.register_payment(address, balance)
if is_paid_enough:
btcd.setaccount(address, btc_account_verifying)
# check btc verifications and clear the transaction if there
# are at least 2 verifications
verifying_addresses = btcd.getaddressesbyaccount(btc_account_verifying)
for address in verifying_addresses:
balance = btcd.getreceivedbyaddress(address, 2)
is_clear = ch_api.try_clearance(address, balance)
if is_clear:
btcd.setaccount(address, btc_account_done)
