def test_can_validate(self):
if False:
working_address = '1CB2fxLGAZEzgaY4pjr4ndeDWJiz3D3AT7'
p = Proxy()
r = p.validateAddress(working_address)
self.assertEqual(r['address'], working_address)
self.assertEqual(r['isvalid'], True)
def payment_request():
"""Generates a http PaymentRequest object"""
bc = Proxy()
btc = bc.getnewaddress()
# Setting the 'amount' field to 0 (zero) should prompt the user to enter
# the amount for us but a bug in bitcoin core qt version 0.9.1 (at time of
# writing) wrongly informs us that the value is too small and aborts.
# https://github.com/bitcoin/bitcoin/issues/3095
# Also there can be no leading 0's (zeros).
btc_amount = 100000
serialized_pubkey = btc.to_scriptPubKey()
pdo = o.PaymentDetails()
# pdo.network = 'test'
pdo.outputs.add(amount=btc_amount, script=serialized_pubkey)
pdo.time = int(time())
pdo.memo = "String shown to user before confirming payment"
pdo.payment_url = "http://payment_ack.url"
pro = o.PaymentRequest()
pro.serialized_payment_details = pdo.SerializeToString()
sds_pr = pro.SerializeToString()
open("sds_pr_blob", "wb").write(sds_pr)
headers = {"Content-Type": "application/bitcoin-payment", "Accept": "application/bitcoin-paymentrequest"}
http_response_object = urllib2.Request("file:sds_pr_blob", None, headers)
return http_response_object
def payment_request():
"""Generates a http PaymentRequest object"""
bc = Proxy()
btc = bc.getnewaddress()
# Setting the 'amount' field to 0 (zero) should prompt the user to enter
# the amount for us but a bug in bitcoin core qt version 0.9.1 (at time of
# writing) wrongly informs us that the value is too small and aborts.
# https://github.com/bitcoin/bitcoin/issues/3095
# Also there can be no leading 0's (zeros).
btc_amount = 100000
serialized_pubkey = btc.to_scriptPubKey()
pdo = o.PaymentDetails()
#pdo.network = 'test'
pdo.outputs.add(amount=btc_amount, script=serialized_pubkey)
pdo.time = int(time())
pdo.memo = 'String shown to user before confirming payment'
pdo.payment_url = 'http://payment_ack.url'
pro = o.PaymentRequest()
pro.serialized_payment_details = pdo.SerializeToString()
sds_pr = pro.SerializeToString()
open('sds_pr_blob', 'wb').write(sds_pr)
headers = {
'Content-Type': 'application/bitcoin-payment',
'Accept': 'application/bitcoin-paymentrequest'
}
http_response_object = urllib2.Request('file:sds_pr_blob', None, headers)
return http_response_object
def bitcoin_rpc(*args, **kwargs):
'''
Wrapper of bitcoin.rpc
'''
try:
rpc = Proxy(settings.BITCOIN_API)
return rpc._call(*args, **kwargs)
except Exception as err:
logging.error(err)
return False
def rpc_client_factory():
bitcoin_conf: Path = bitcoin_conf_path()
if bitcoin_conf.exists():
logger.info("Using config file: %s", bitcoin_conf)
return lambda: Proxy(btc_conf_file=bitcoin_conf, timeout=TIMEOUT)
else:
host = BITCOIN_RPC_HOST
if BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD:
host = "%s:%s@%s" % (quote(BITCOIN_RPC_USER), quote(BITCOIN_RPC_PASSWORD), host,)
if BITCOIN_RPC_PORT:
host = "%s:%s" % (host, BITCOIN_RPC_PORT)
service_url = "%s://%s" % (BITCOIN_RPC_SCHEME, host)
return lambda: Proxy(service_url=service_url, timeout=TIMEOUT)
def syncWallet(result, wallet, gaitwallet, path):
hexprivkey = wallet.subkey(1).subkey(result['pointer']).wif()
hexpubkey = wallet.subkey(1).subkey(result['pointer']).public_copy().sec_as_hex()
tproxy = Proxy()
GAKey = gaitwallet.subkey(1).subkey_for_path(path).subkey(result['pointer']).sec_as_hex()
addrfromapi = P2SHBitcoinAddress.from_redeemScript(CScript(binascii.unhexlify(result['script'])))
print(addrfromapi)
#tproxy.call("importprivkey", hexprivkey, "", False)
print(tproxy.call("createmultisig", 2, [GAKey, hexpubkey])['address'])
class BitcoinRpc():
bitcoin_proxy = None
def __init__(self):
self.bitcoin_proxy = Proxy()
def get_new_address(self):
return self.bitcoin_proxy.getnewaddress()
def get_balance(self):
return self.bitcoin_proxy.getbalance()
def get_transaction(self, txid):
return self.bitcoin_proxy.gettransaction(lx(txid))
def bitcoinrpc(*args):
host = BITCOIN_RPC_HOST
if BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD:
host = "%s:%s@%s" % (
quote(BITCOIN_RPC_USER),
quote(BITCOIN_RPC_PASSWORD),
host,
)
if BITCOIN_RPC_PORT:
host = "%s:%s" % (host, BITCOIN_RPC_PORT)
service_url = "%s://%s" % (BITCOIN_RPC_SCHEME, host)
proxy = Proxy(service_url=service_url)
result = proxy.call(*args)
return result
def init(config, blocksToMine):
"""
clears any old regtest blocks
creates rpc
starts bitcoind
:param config:
:param network:
:return: proxy obj, miner priv, miner addr, block hashes of coinbases that can be spent
"""
clearBitcoinChain(config)
startBitcoind(config)
objRpcB = Proxy(btc_conf_file=config.bitcoinConfPath)
objRpcB = waitForBitcoind(config, objRpcB)
objPrivMiner = pycrypto.PrivateKey(constants.bCoinbasePriv)
pubMiner = objPrivMiner.pub(compressed=True)
xPubMiner = str(pubMiner)
strAddrMiner = str(pubMiner.to_address(mainnet=False))
objRpcB = addPrivToBitcoind(config, objRpcB, constants.iCoinbasePriv,
xPubMiner, strAddrMiner)
hundredBlockRounds = blocksToMine // 100
remainder = blocksToMine % 100
strBlockHashes = []
for i in range(0, hundredBlockRounds):
hashes, objRpcB = bitcoinCli(config, objRpcB, "generatetoaddress", 100,
strAddrMiner)
strBlockHashes += hashes
if remainder != 0:
hashes, objRpcB = bitcoinCli(config, objRpcB, "generatetoaddress",
remainder, strAddrMiner)
strBlockHashes += hashes
return objRpcB, objPrivMiner, strAddrMiner, strBlockHashes[:-100]
def get_core_priv():
proxy = Proxy()
address = proxy.getnewaddress()
# address = 'tb1qntuv4la0lh072jtr6ce3avrsghnc200dgamlpq'
proxy._call("walletpassphrase", "P@55w0rd", 5)
wif = proxy.dumpprivkey(address)
proxy._call("walletlock")
print("address", address)
return CBitcoinSecret(str(wif))
def __init__(self, logger=None, test=False):
self.logger = logger or logging.getLogger(__name__)
# Setup logging file handler
self.logger.setLevel(logging.DEBUG)
self.handler = logging.FileHandler(__name__ + '.log')
self.handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - ' +
'%(levelname)s:\n\t %(message)s')
self.handler.setFormatter(formatter)
self.logger.addHandler(self.handler)
self.test = test
# if test:
# SelectParams('testnet')
if not test:
self.proxy = Proxy()
def rpc_client_factory():
# Configuration is done in this order of precedence:
# - Explicit config file.
# - BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD environment variables.
# - Default bitcoin config file (as handled by Proxy.__init__).
use_conf = ((BITCOIN_CONF_PATH is not None) or (BITCOIN_RPC_USER is None)
or (BITCOIN_RPC_PASSWORD is None))
if use_conf:
logger.info("Using config file: %s", BITCOIN_CONF_PATH or "<default>")
return lambda: Proxy(btc_conf_file=BITCOIN_CONF_PATH, timeout=TIMEOUT)
else:
host = BITCOIN_RPC_HOST
host = "{}:{}@{}".format(BITCOIN_RPC_USER, BITCOIN_RPC_PASSWORD, host)
if BITCOIN_RPC_PORT:
host = "{}:{}".format(host, BITCOIN_RPC_PORT)
service_url = "{}://{}".format(BITCOIN_RPC_SCHEME, host)
logger.info("Using environment configuration")
return lambda: Proxy(service_url=service_url, timeout=TIMEOUT)
async def _cmd_deposit(client, message, params):
if not params[0] == _CMD_STR_DEPOSIT:
return
username = str(message.author)
userid = str(message.author.id)
user_mention = message.author.mention
if (len(params) >= 2):
await client.send_message(message.channel,
"{0}！使い方を調べてきなさい！".format(user_mention))
return
# userid でDBからaddr取得
addr = ''
with closing(sqlite3.connect(DBNAME)) as connection:
cursor = connection.cursor()
row = dbaccessor.get_user_row(cursor, userid)
# print(row)
if row is not None:
addr = row[walletdb.WalletNum.ADDR.value]
if addr == INIT_ADDR_DUMMY:
p = Proxy()
addr = p.getnewaddress()
if not dbaccessor.update_address(cursor, userid, addr):
await client.send_message(
message.channel, "{0}！失敗したわね！！".format(user_mention))
return
connection.commit()
else:
await client.send_message(message.channel,
"{0}！聞いたこと無い名前ね！".format(user_mention))
return
################################
ad_src = "**address**\r\n{0}\r\n".format(addr)
disp_msg = ad_src
await _disp_rep_msg(client, message, username, '', disp_msg)
################################
return
def __init__(self, settings):
from bitcoin import SelectParams
from bitcoin.rpc import Proxy
self.account = settings.get('ACCOUNT', 'ccvpn3')
chain = settings.get('CHAIN')
if chain:
SelectParams(chain)
self.url = settings.get('URL')
if not self.url:
return
self.make_rpc = lambda: Proxy(self.url)
self.rpc = self.make_rpc()
self.backend_enabled = True
def bitcoinCli(config, objRpcB, cmd, *args):
"""
runs a bitcoin client command using the proxy object. If connection is broken, we create a new object and try again.
Every call to bitcoinCli should use this wrapper
:param config: config
:param objRpcB: proxy object
:param cmd: str of command to call
:param args: arguments to pass into command
:return: result of bitcoin-cli call, latest proxy object
"""
while True:
try:
r = objRpcB.call(cmd, *args)
break
except BrokenPipeError:
objRpcB = Proxy(btc_conf_file=config.bitcoinConfPath)
return r, objRpcB
def create_app(log_level="INFO", config="config.yml"):
app = Flask(__name__)
app.secret_key = 'test'
app.config.from_object(__name__)
config_vars = yaml.load(open(root + '/config.yml'))
# inject all the yaml configs
app.config.update(config_vars)
db.init_app(app)
Migrate(app, db)
# Setup redis
redis_config = app.config.get('redis_conn', dict(type='live'))
typ = redis_config.pop('type')
if typ == "mock_redis":
from mockredis import mock_redis_client
app.redis = mock_redis_client()
else:
app.redis = Redis(**redis_config)
del app.logger.handlers[0]
app.logger.setLevel(logging.NOTSET)
log_format = logging.Formatter(
'%(asctime)s [%(name)s] [%(levelname)s]: %(message)s')
log_level = getattr(logging, str(log_level),
app.config.get('log_level', "INFO"))
logger = logging.getLogger()
logger.setLevel(log_level)
handler = logging.StreamHandler(stream=sys.stdout)
handler.setFormatter(log_format)
logger.addHandler(handler)
# Dynamically add all the filters in the filters.py file
for name, func in inspect.getmembers(filters, inspect.isfunction):
app.jinja_env.filters[name] = func
app.rpc_connection = Proxy("http://{0}:{1}@{2}:{3}/".format(
app.config['coinserv']['username'], app.config['coinserv']['password'],
app.config['coinserv']['address'], app.config['coinserv']['port']))
from . import views
app.register_blueprint(views.main)
return app
import sys
if sys.version_info.major < 3:
sys.stderr.write("Sorry, Python 3.x required by this example.\n")
sys.exit(1)
import hashlib
from bitcoin import SelectParams
from bitcoin.core import b2x, b2lx, lx, COIN, COutPoint, CTxOut, CTxIn, CTxInWitness, CTxWitness, CScriptWitness, CMutableTransaction, Hash160
from bitcoin.core.script import CScript, OP_0, SignatureHash, SIGHASH_ALL, SIGVERSION_WITNESS_V0
from bitcoin.wallet import CBitcoinSecret, P2WPKHBitcoinAddress
from bitcoin.rpc import Proxy
SelectParams("regtest")
connection = Proxy()
if connection._call("getblockchaininfo")["chain"] != "regtest":
sys.stderr.write("This example is intended for regtest only.\n")
sys.exit(1)
# Create the (in)famous correct brainwallet secret key.
h = hashlib.sha256(b'correct horse battery staple').digest()
seckey = CBitcoinSecret.from_secret_bytes(h)
# Create an address from that private key.
public_key = seckey.pub
scriptPubKey = CScript([OP_0, Hash160(public_key)])
address = P2WPKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
# Give the private key to bitcoind (for ismine, listunspent, etc).
def __init__(self):
self.bitcoin_proxy = Proxy()
#!/usr/bin/env python
import codecs
from bitcoin.rpc import Proxy
if __name__ == '__main__':
url = raw_input('Please enter the RPC url: ')
username = raw_input('Please enter the RPC username: '******'Please enter the RPC password: '******'out.csv', 'w', 'utf-8')
for idx in xrange(numblocks):
blockinfo = proxy.getblock(proxy.getblockhash(idx))
fp.write(','.join(map(str, [
blockinfo['height'],
blockinfo['time'],
blockinfo['difficulty'],
]))+'\n')
fp.close()
class BitcoinNode(Node):
__slots__ = [
'_path', '_spent_to', '_rpc_connection', '_current_tx_chain_index',
'_tx_chains'
]
def __init__(self, name, group, ip, docker_image, path):
super().__init__(name, group, ip, docker_image)
self._path = path
self._spent_to = None
self._rpc_connection = None
self._current_tx_chain_index = 0
self._tx_chains = []
def exec_event_cmd(self, cmd: str, args: List[str] = []):
if cmd == 'tx':
self.generate_tx
elif cmd == 'block':
self.generate_blocks(amount=1)
else:
raise Exception("Unknown cmd {cmd} for node {node}", cmd, self)
def exec_event_cmd_string(self, cmd: str, args: List[str] = []) -> str:
if cmd == 'tx':
# TODO fix transactions
#return self.generate_tx_string()
return ""
elif cmd == 'block':
return self.generate_blocks_string(amount=1)
else:
raise Exception("Unknown cmd {cmd} for node {node}", cmd, self)
def create_conf_file(self):
# file is needed for RPC connection
with open(config.btc_conf_file.format(self.name), 'w') as file:
file.write('rpcconnect={}\n'.format(self._ip))
file.write('rpcport={}\n'.format(config.rpc_port))
file.write('rpcuser={}\n'.format(config.rpc_user))
file.write('rpcpassword={}\n'.format(config.rpc_password))
def run(self, connect_to_ips):
bash.check_output(
bitcoincmd.start(self._name, str(self._ip), self._docker_image,
self._path, connect_to_ips))
def is_running(self):
return bash.check_output(dockercmd.check_if_running(
self._name)) == 'true'
def close_rpc_connection(self):
if self._rpc_connection is not None:
self._rpc_connection.__dict__['_BaseProxy__conn'].close()
logging.debug('Closed rpc connection to node={}'.format(
self._name))
def stop(self):
# self.execute_rpc('stop')
# bash.check_output(self.execute_rpc_string(('stop', '')))
bash.check_output(
f"docker exec simcoin-{self._name} bitcoin-cli -regtest -rpcuser=admin -rpcpassword=admin stop"
)
logging.info('Send stop to node={}'.format(self.name))
def get_log_file(self):
return self._path + config.bitcoin_log_file_name
def wait_until_rpc_ready(self):
logging.debug("# Waiting for docker instances to become ready")
while True:
try:
bash.check_output("nc -z -w1 {} {}".format(
self._ip, config.rpc_port),
purpose="Wait for port beeing open")
logging.info(f"Success for {self.ip}")
break
except Exception:
logging.debug("Waiting with netcat until port is open")
while True:
try:
self.execute_rpc('getnetworkinfo')
break
except JSONRPCError:
logging.debug('Waiting until RPC of node={} is ready.'.format(
self._name))
utils.sleep(1)
def connect_to_rpc(self):
self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format(
self.name),
timeout=config.rpc_timeout)
def rm_peers_file(self):
return bash.check_output(bitcoincmd.rm_peers(self._name))
def execute_rpc(self, *args):
retry = 30
while retry > 0:
try:
return self._rpc_connection.call(args[0], *args[1:])
except (IOError, CannotSendRequest) as error:
logging.exception(
'Could not execute RPC-call={} on node={} because of error={}.'
' Reconnecting and retrying, {} retries left'.format(
args[0], self._name, error, retry))
retry -= 1
self.connect_to_rpc()
raise Exception('Could not execute RPC-call={} on node {}'.format(
args[0], self._name))
def transfer_coinbases_to_normal_tx(self):
for tx_chain in self._tx_chains:
tx_chain.amount /= 2
logging.info(
f'transfer_coinbase_to_normal_tx tx_chain.amount = {tx_chain.amount}'
)
tx_chain.amount -= int(config.transaction_fee / 2)
logging.info(
f'transfer_coinbase_to_normal_tx tx_chain.amount = {tx_chain.amount}'
)
tx_chain.amount = math.floor(
tx_chain.amount
) # TODO find better fix for 'Invalid amount' json_rpc error
raw_transaction = self.execute_rpc(
'createrawtransaction', [{
'txid': tx_chain.current_unspent_tx,
'vout': 0,
}],
OrderedDict([
(tx_chain.address, str(tx_chain.amount / 100000000)),
(self._spent_to.address, str(tx_chain.amount / 100000000))
]))
signed_raw_transaction = self.execute_rpc('signrawtransaction',
raw_transaction)['hex']
tx_chain.current_unspent_tx = self.execute_rpc(
'sendrawtransaction', signed_raw_transaction)
def generate_blocks(self, amount=1):
logging.debug('{} trying to generate block'.format(self._name))
block_hash = self.execute_rpc('generate', amount)
logging.info('{} generated block with hash={}'.format(
self._name, block_hash))
def generate_blocks_string(self, amount=1) -> str:
return self.execute_rpc_string('generate ', amount) # TODO fix amount
def generate_tx(self):
tx_chain = self.get_next_tx_chain()
txid = lx(tx_chain.current_unspent_tx)
txins = [
CMutableTxIn(COutPoint(txid, 0)),
CMutableTxIn(COutPoint(txid, 1))
]
txin_seckeys = [tx_chain.seckey, self._spent_to.seckey]
amount_in = tx_chain.amount
tx_chain.amount -= int(config.transaction_fee / 2)
txout1 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(tx_chain.address).to_scriptPubKey())
txout2 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(self._spent_to.address).to_scriptPubKey())
tx = CMutableTransaction(txins, [txout1, txout2], nVersion=2)
for i, txin in enumerate(txins):
txin_scriptPubKey = CScript([
OP_DUP, OP_HASH160,
Hash160(txin_seckeys[i].pub), OP_EQUALVERIFY, OP_CHECKSIG
])
sighash = SignatureHash(txin_scriptPubKey, tx, i, SIGHASH_ALL)
sig = txin_seckeys[i].sign(sighash) + bytes([SIGHASH_ALL])
txin.scriptSig = CScript([sig, txin_seckeys[i].pub])
tx_serialized = tx.serialize()
logging.debug('{} trying to sendrawtransaction'
' (in=2x{} out=2x{} fee={} bytes={})'
' using tx_chain number={}'.format(
self._name, amount_in, txout1.nValue,
(amount_in * 2) - (txout1.nValue * 2),
len(tx_serialized), self._current_tx_chain_index))
tx_hash = self.execute_rpc('sendrawtransaction', b2x(tx_serialized))
tx_chain.current_unspent_tx = tx_hash
logging.info(
'{} sendrawtransaction was successful; tx got hash={}'.format(
self._name, tx_hash))
def generate_spent_to_address(self):
address = self.execute_rpc('getnewaddress')
seckey = CBitcoinSecret(self.execute_rpc('dumpprivkey', address))
self._spent_to = SpentToAddress(address, seckey)
def create_tx_chains(self):
for unspent_tx in self.execute_rpc('listunspent'):
seckey = CBitcoinSecret(
self.execute_rpc('dumpprivkey', unspent_tx['address']))
tx_chain = TxChain(unspent_tx['txid'], unspent_tx['address'],
seckey, unspent_tx['amount'] * 100000000)
self._tx_chains.append(tx_chain)
def get_next_tx_chain(self):
tx_chain = self._tx_chains[self._current_tx_chain_index]
self._current_tx_chain_index = ((self._current_tx_chain_index + 1) %
len(self._tx_chains))
return tx_chain
def connect_to_rpc(self):
self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format(
self.name),
timeout=config.rpc_timeout)
def run(self, id, nodes, start_at_timestamp):
# all times are in seconds
s = Scheduler2(int(start_at_timestamp))
blocktime = 0.2 # seconds
self.set_network_delay()
s.wait()
self.startd()
self.rpc = Proxy(service_url="http://*****:*****@localhost:18332")
self.rpc_a = RawProxy(service_url="http://*****:*****@localhost:18332")
generateBlock = lambda: self.rpc.generate(1)
getChainTips = lambda: self.rpc_a.getchaintips()
s.save_sleep(15)
logger.error(f"[{id}] setup phase complete ")
# generate first round blocks
s.save_sleep(id * blocktime)
generateBlock()
logger.error(f"[{id}] generated initial blocks")
s.save_sleep((nodes - id) * blocktime + 0.5)
# generate doublespends, synchronous block creation
for _ in range(10):
if id % 2 == 1:
s.save_sleep(blocktime + 0.2)
generateBlock()
s.save_sleep(0.2)
logger.error(f"[{id}] Tick")
else:
s.save_sleep(0.2)
generateBlock()
logger.error(f"[{id}] Tock")
s.save_sleep(blocktime + 0.2)
# generate last round of blocks
logger.error(f"[{id}] Last round")
s.save_sleep(id * blocktime)
generateBlock()
s.save_sleep((nodes - id) * blocktime + 0.2)
logger.error(f"[{id}] Done")
# the following part uses cog as code generation tool
# python -mpip install cogapp
# python -mcogapp -r p.py
# [[[cog
# import cog
# cog.out("print('hello')")
# ]]]
print('hello')
tips = getChainTips()
# [[[end]]]
self.stopd()
print(tips)
with open("output.tape","w") as out:
out.write(str(tips))
exit()
def validateChange(result, wallet, path):
prox = Proxy()
tx = prox.decoderawtransaction(result['tx'])
changeAddrKey = wallet.subkey(1).subkey(result['change_pointer']).public_copy().sec_as_hex()
class TX(object):
def __init__(self, logger=None, test=False):
self.logger = logger or logging.getLogger(__name__)
# Setup logging file handler
self.logger.setLevel(logging.DEBUG)
self.handler = logging.FileHandler(__name__ + '.log')
self.handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - ' +
'%(levelname)s:\n\t %(message)s')
self.handler.setFormatter(formatter)
self.logger.addHandler(self.handler)
self.test = test
# if test:
# SelectParams('testnet')
if not test:
self.proxy = Proxy()
def __del__(self):
self.handler.close()
###########################################################################
## General TX Functions
###########################################################################
def get_tx(self,
redeem_script,
address,
amount,
funding_tx,
lock_time=0,
vout=0):
'''
Returns a raw transaction and it's signature hash
that pays to address from funding_tx
Options:
vout -> which vout of funding_tx
nLockTime -> set's transaction locktime
'''
# Set P2SH funding tx in little-endian
fx = lx(funding_tx)
if lock_time > 0:
nlock_time = lock_time
else:
nlock_time = 0
# nSequence must be any number less than 0xffffffff to enable nLockTime
if (nlock_time != 0):
txin = CMutableTxIn(COutPoint(fx, vout), nSequence=0)
else:
txin = CMutableTxIn(COutPoint(fx, vout))
# Convert amount to Satoshi's
amount *= COIN
# Create the txout to address
script_pubkey = CBitcoinAddress(address).to_scriptPubKey()
txout = CMutableTxOut(amount, script_pubkey)
# Create the unsigned transaction.
tx = CMutableTransaction([txin], [txout], nLockTime=nlock_time)
# Calculte TX sig hash
sighash = SignatureHash(CScript(redeem_script), tx, 0, SIGHASH_ALL)
self.logger.info("get_tx: TX SIGHASH is %s", b2x(sighash))
return (tx.serialize(), sighash)
def refund_tx(self, payer_sig, serial_tx, redeem_script):
'''
Sends a transaction refunding the funder of
the P2SH address.
'''
# Read in transaction
temp_tx = CTransaction.deserialize(serial_tx)
tx = CMutableTransaction.from_tx(temp_tx)
txin = tx.vin[0]
# Set script sig
txin.scriptSig = CScript([payer_sig + '\x01', OP_FALSE, redeem_script])
# Verify script
redeem_script = CScript(redeem_script)
VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx,
0, [SCRIPT_VERIFY_P2SH])
serial_tx = tx.serialize()
if not self.test:
# txid = self.self.proxy.sendrawtransaction(tx)
txid = b2lx(Hash(serial_tx))
else:
txid = b2lx(Hash(serial_tx))
self.logger.info("refund_tx: TXID is %s", txid)
self.logger.info("refund_tx: RAW TX is %s", b2x(serial_tx))
return serial_tx
###########################################################################
## Serialization related
###########################################################################
def serialize_list(self, l):
'''
Serializes a python list
'''
serial = ""
for i in range(len(l)):
serial += l[i]
return serial
def get_keys_from_tx(self, serial_tx, n_keys=15):
'''Extracts n_keys from tx in serial form'''
# Read in transaction
temp_tx = CTransaction.deserialize(serial_tx)
tx = CMutableTransaction.from_tx(temp_tx)
# Keys are in txin.scriptSig
txin = tx.vin[0]
script = txin.scriptSig
# Extract keys from script
keys = []
for i, op in enumerate(script):
if i in range(1, n_keys + 1):
keys += [op]
# Serialize keys in correct order
serial_keys = ""
for op in reversed(keys):
serial_keys += op
return serial_keys
def get_keys_from_serial(self, serial, n_keys=15, key_len=16):
''' Returns a list of n_keys of key_len extracted from serial'''
expected = (n_keys * key_len)
if len(serial) != expected:
self.logger.error(
"get_keys_from_serial: serial len is %d " + "expected %d",
len(serial), expected)
return []
keys = []
for i in range(n_keys):
keys += [serial[i * key_len:key_len * (i + 1)]]
return keys
def get_hashes_from_serial(self, serial, n_hashes, hash_len):
''' Returns a list of n_hashes of hash_len extracted from serial'''
expected = (n_hashes * hash_len)
if len(serial) != expected:
self.logger.error(
"get_hashes_from_serial: serial len is %d " + "expected %d",
len(serial), expected)
return []
hashes = []
for i in range(n_hashes):
hashes += [serial[i * hash_len:hash_len * (i + 1)]]
return hashes
###########################################################################
## Preimage P2SH wth Refund
###########################################################################
def create_hash_script(self, redeemer_pubkey, hashes):
'''
Creates part of the redeem script that deals
with the hashes
'''
script = []
for h in hashes:
script += [OP_RIPEMD160, h, OP_EQUALVERIFY]
script += [redeemer_pubkey, OP_CHECKSIG]
return script
def setup_preimage(self, payer_pubkey, redeemer_pubkey, hashes, amount,
lock_time):
'''
Setups a P2SH that can only be redeemed
if the redeemer is able to provide
the hash preimages.
Also, sends a tx funding the escrow
(Assumes payer calls the setup)
'''
# Set locktime relative to current block
if not self.test:
lock = self.proxy.getblockcount() + lock_time
else:
lock = lock_time
script = self.create_hash_script(redeemer_pubkey, hashes)
redeem_script = CScript([OP_IF] + script + [
OP_ELSE, lock, OP_CHECKLOCKTIMEVERIFY, OP_DROP, payer_pubkey,
OP_CHECKSIG, OP_ENDIF
])
redeem = b2x(redeem_script)
self.logger.info("setup_preimage: Redeem script is %s", redeem)
# Get P2SH address
# 1. Get public key
script_pub_key = redeem_script.to_p2sh_scriptPubKey()
# 2. Get bitcoin address
p2sh_address = CBitcoinAddress.from_scriptPubKey(script_pub_key)
self.logger.info("setup_preimage: P2SH is %s", str(p2sh_address))
# 3. Fund address
if not self.test:
# funding_tx = self.proxy.call("sendtoaddress", str(p2sh_address),
# amount)
funding_tx = FUNDING_TX
self.logger.info("setup_preimage: P2SH Fund TX is %s", funding_tx)
else:
funding_tx = FUNDING_TX
return (redeem_script, str(funding_tx), str(p2sh_address), str(lock))
def spend_preimage(self, preimages, redeemer_sig, serial_tx,
redeem_script):
'''
Sends a transaction fulfilling the redeem script
of the preimage P2SH
'''
# Read in transaction
temp_tx = CTransaction.deserialize(serial_tx)
tx = CMutableTransaction.from_tx(temp_tx)
txin = tx.vin[0]
# Setup preimages in reverse order
script = []
for p in reversed(preimages):
script += [p]
# Create script sig
txin.scriptSig = CScript([redeemer_sig + '\x01'] + script +
[OP_TRUE, redeem_script])
# Verify script
redeem_script = CScript(redeem_script)
VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx,
0, [SCRIPT_VERIFY_P2SH])
serial_tx = tx.serialize()
if not self.test:
# txid = self.proxy.sendrawtransaction(tx)
txid = b2lx(Hash(serial_tx))
else:
txid = b2lx(Hash(serial_tx))
self.logger.info("spend_preimage: TXID is %s", txid)
self.logger.info("spend_preimage: RAW TX is %s", b2x(serial_tx))
return serial_tx
###########################################################################
## Two Party Escrow with Refund
###########################################################################
def setup_escrow(self, payer_pubkey, redeemer_pubkey, amount, lock_time):
'''
Setups a 2of2 escrow with payer and redeemer
Also, sends a tx funding the escrow
(Assumes payer calls the setup)
'''
# Set locktime relative to current block
if not self.test:
lock = self.proxy.getblockcount() + lock_time
self.logger.info("setup_escrow: Locktime is %d", lock)
else:
lock = lock_time
redeem_script = CScript([
OP_IF, OP_2, payer_pubkey, redeemer_pubkey, OP_2, OP_CHECKMULTISIG,
OP_ELSE, lock, OP_CHECKLOCKTIMEVERIFY, OP_DROP, payer_pubkey,
OP_CHECKSIG, OP_ENDIF
])
redeem = b2x(redeem_script)
self.logger.info("setup_escrow: Redeem script is %s", redeem)
# Get P2SH address
# 1. Get public key
script_pub_key = redeem_script.to_p2sh_scriptPubKey()
# 2. Get bitcoin address
p2sh_address = CBitcoinAddress.from_scriptPubKey(script_pub_key)
self.logger.info("setup_escrow: P2SH is %s", str(p2sh_address))
# 3. Fund address
if not self.test:
funding_tx = self.proxy.call("sendtoaddress", str(p2sh_address),
amount)
self.logger.info("setup_escrow: P2SH Fund TX is %s", funding_tx)
else:
funding_tx = FUNDING_TX
return (redeem_script, str(funding_tx), str(p2sh_address), str(lock))
def spend_escrow(self, payer_sig, redeemer_sig, serial_tx, redeem_script):
'''
Sends a transaction fulfilling the redeem script of escrow tx
'''
# Read in transaction
temp_tx = CTransaction.deserialize(serial_tx)
tx = CMutableTransaction.from_tx(temp_tx)
txin = tx.vin[0]
# Set script sig
txin.scriptSig = CScript([
OP_FALSE, payer_sig + '\x01', redeemer_sig + '\x01', OP_TRUE,
redeem_script
])
# Verify script
redeem_script = CScript(redeem_script)
serial_tx = tx.serialize()
VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx,
0, [SCRIPT_VERIFY_P2SH])
serial_tx = tx.serialize()
if not self.test:
# txid = self.proxy.sendrawtransaction(tx)
txid = b2lx(Hash(serial_tx))
else:
txid = b2lx(Hash(serial_tx))
self.logger.info("spend_escrow: TXID is %s", txid)
self.logger.info("spend_escrow: RAW TX is %s", b2x(serial_tx))
return serial_tx
from bitcoin.rpc import Proxy
from django.conf import settings
RPC_USERNAME = settings.BITCOINZ_RPC_USERNAME
RPC_PASSWORD = settings.BITCOINZ_RPC_PASSWORD
RPC_URL = settings.BITCOINZ_RPC_URL
RPC_PROXY = settings.BITCOINZ_RPC_PROXY
rpc_proxy = Proxy(service_url=RPC_URL,
rpc_username=RPC_USERNAME,
rpc_password=RPC_PASSWORD,
proxy=RPC_PROXY)
class Gateway:
def create_transaction(self,
buyer_email,
amount,
currency='BTC',
currency1='BTC',
currency2='BTC'):
pass
def get_transactions(self):
pass
def get_transaction(self, transaction_id):
pass
def get_address(self, account):
return rpc_proxy.getnewaddress()
import ago
import logging
import sqlalchemy.exc
from decimal import Decimal
from bitcoin.rpc import Proxy
from flask import (Flask, jsonify, render_template, session, redirect, url_for,
Response, stream_with_context, g)
from flask.ext.sqlalchemy import SQLAlchemy
import config
app = Flask(__name__, static_url_path='/static')
app.secret_key = "tsdkfljglkjsdfg"
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///index.db'
proxies = {}
for conf in config.proxy_addresses:
p = Proxy(conf['address'])
p.name = conf['name']
proxies[conf['name']] = p
block_cache = {}
# We store needed block information that is an ephemeral cache
db = SQLAlchemy(app)
@app.before_request
def add_proxies():
g.proxies = proxies
@app.template_filter('human_date')
def human_date_utc(*args, **kwargs):
argv = FLAGS(sys.argv)
except gflags.FlagsError, e:
print '%s\n\nUsage %s ARGS \n%s' % (e, sys.argv[0], FLAGS)
sys.exit(1)
if FLAGS.testnet:
class BitcoinTestnetAddress(BitcoinAddress):
PUBKEY_HASH = 111
SCRIPT_HASH = 196
BitcoinAddress = BitcoinTestnetAddress
else:
print '%s is NOT ready for primetime; run with --testnet' % sys.argv[0]
sys.exit(0)
kwargs = {}
kwargs['username'] = FLAGS.username
kwargs['password'] = FLAGS.password
kwargs['timeout'] = FLAGS.timeout
from bitcoin.rpc import Proxy
rpc = Proxy('http://%s:%d/' % (FLAGS.host, FLAGS.port), **kwargs)
session = Session()
sync_unspent_outputs(rpc, session)
import IPython
IPython.embed()
import sys
from os import environ
if sys.version_info.major < 3:
sys.stderr.write('Sorry, Python 3.x required by this example.\n')
sys.exit(1)
from hashlib import sha256
from enum import Enum
from bitcoin import SelectParams
from bitcoin.core import b2x, b2lx, x, Hash160, Hash
from bitcoin.core.script import CScript, OP_HASH160, OP_EQUAL, OP_CHECKSIG, OP_EQUALVERIFY, OP_DUP, OP_0
from bitcoin.wallet import CBitcoinAddress, CBitcoinSecret
from bitcoin.rpc import Proxy
SelectParams('testnet')
proxy = Proxy()
# Not recognized when datadir conf param is present
Sha256 = lambda x: sha256(x).digest()
Hash256 = lambda x: Hash(x)
def patch(asm):
full = asm
asm = ''
for i in full:
if i == "" or i == "0": i = '0P_0'
if i == 'OP_NOP1': i = 'OP_DESERIALIZE'
asm += i + ' '
return asm.strip()
import ago
import logging
import sqlalchemy.exc
from decimal import Decimal
from bitcoin.rpc import Proxy
from flask import (Flask, jsonify, render_template, session, redirect, url_for,
Response, stream_with_context, g)
from flask.ext.sqlalchemy import SQLAlchemy
import config
app = Flask(__name__, static_url_path='/static')
app.secret_key = "tsdkfljglkjsdfg"
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///index.db'
proxies = {}
for conf in config.proxy_addresses:
p = Proxy(conf['address'])
p.name = conf['name']
proxies[conf['name']] = p
block_cache = {}
# We store needed block information that is an ephemeral cache
db = SQLAlchemy(app)
@app.before_request
def add_proxies():
g.proxies = proxies
@app.template_filter('human_date')
def human_date_utc(*args, **kwargs):
if isinstance(args[0], type(None)):
return "never"
def create_app(log_level="INFO",
config="/config.yml",
global_config="/global.yml"):
app = Flask(__name__, static_folder='../static', static_url_path='/static')
app.secret_key = 'test'
app.config.from_object(__name__)
# inject all the yaml configs
try:
global_config_vars = yaml.load(open(root + global_config))
app.config.update(global_config_vars)
except FileNotFoundError:
pass
config_vars = yaml.load(open(root + config))
app.config.update(config_vars)
# set our template paths
custom_template_path = app.config.get('custom_template_path',
'lincoln/custom_templates')
template_paths = [
os.path.join(root, custom_template_path),
os.path.join(root, 'lincoln/templates')
]
template_loader = jinja2.ChoiceLoader(
[jinja2.FileSystemLoader(template_paths), app.jinja_loader])
app.jinja_loader = template_loader
# Init the db & migrations
db.init_app(app)
Migrate(app, db)
# Setup redis
redis_config = app.config.get('redis_conn', dict(type='live'))
typ = redis_config.pop('type')
if typ == "mock_redis":
from mockredis import mock_redis_client
app.redis = mock_redis_client()
else:
app.redis = Redis(**redis_config)
del app.logger.handlers[0]
app.logger.setLevel(logging.NOTSET)
log_format = logging.Formatter(
'%(asctime)s [%(name)s] [%(levelname)s]: %(message)s')
app.log_level = getattr(logging, str(log_level),
app.config.get('log_level', "INFO"))
logger = logging.getLogger()
logger.setLevel(app.log_level)
handler = logging.StreamHandler(stream=sys.stdout)
handler.setFormatter(log_format)
logger.addHandler(handler)
# try and fetch the git version information
try:
output = subprocess.check_output(b"git show -s --format='%ci %h'",
shell=True).strip().rsplit(b" ", 1)
app.config['hash'] = output[1]
app.config['revdate'] = output[0]
# celery won't work with this, so set some default
except Exception:
app.config['hash'] = ''
app.config['revdate'] = ''
# Dynamically add all the filters in the filters.py file
for name, func in inspect.getmembers(filters, inspect.isfunction):
app.jinja_env.filters[name] = func
app.rpc_connection = Proxy("http://{0}:{1}@{2}:{3}/".format(
app.config['coinserv']['username'], app.config['coinserv']['password'],
app.config['coinserv']['address'], app.config['coinserv']['port']))
from . import views
app.register_blueprint(views.main)
return app
class Process:
""" TODO startsignal """
#def __init__(self):
# DONE run bitcoind as subprocess
# TODO do something with bitcoind's output, e.g. input/output tape emulation
# TODO run "strategy"
# self.input_i*d_tape = file.read("/id")
def __del__(self):
# TODO stop bitcoind
return True
def run(self, id, nodes, start_at_timestamp):
# all times are in seconds
s = Scheduler2(int(start_at_timestamp))
blocktime = 0.2 # seconds
self.set_network_delay()
s.wait()
self.startd()
self.rpc = Proxy(service_url="http://*****:*****@localhost:18332")
self.rpc_a = RawProxy(service_url="http://*****:*****@localhost:18332")
generateBlock = lambda: self.rpc.generate(1)
getChainTips = lambda: self.rpc_a.getchaintips()
s.save_sleep(15)
logger.error(f"[{id}] setup phase complete ")
# generate first round blocks
s.save_sleep(id * blocktime)
generateBlock()
logger.error(f"[{id}] generated initial blocks")
s.save_sleep((nodes - id) * blocktime + 0.5)
# generate doublespends, synchronous block creation
for _ in range(10):
if id % 2 == 1:
s.save_sleep(blocktime + 0.2)
generateBlock()
s.save_sleep(0.2)
logger.error(f"[{id}] Tick")
else:
s.save_sleep(0.2)
generateBlock()
logger.error(f"[{id}] Tock")
s.save_sleep(blocktime + 0.2)
# generate last round of blocks
logger.error(f"[{id}] Last round")
s.save_sleep(id * blocktime)
generateBlock()
s.save_sleep((nodes - id) * blocktime + 0.2)
logger.error(f"[{id}] Done")
# the following part uses cog as code generation tool
# python -mpip install cogapp
# python -mcogapp -r p.py
# [[[cog
# import cog
# cog.out("print('hello')")
# ]]]
print('hello')
tips = getChainTips()
# [[[end]]]
self.stopd()
print(tips)
with open("output.tape","w") as out:
out.write(str(tips))
exit()
daemon = '/usr/local/bin/bitcoind'
args = {
'regtest': '-regtest',
'datadir': '-datadir=/tmp',
# disable security checks for better performance
'whitelist': '-whitelist=240.0.0.0/4',
# log all events relevant for parsing
'debug': '-debug=cmpctblock -debug=net -debug=mempool',
'logips': '-logips',
'logtimemicros': '-logtimemicros',
# activate listen even though explicit -connect will be set
'connect': '-connect=240.0.0.2', #bootstrap
'listen': '-listen=1',
'listenonion': '-listenonion=0',
'onlynet': '-onlynet=ipv4',
'dnsseed': '-dnsseed=0',
'reindex': '-reindex',
'checkmempool': '-checkmempool=0',
'keypool': '-keypool=1',
# RPC configuration
'rpcuser': '******',
'rpcpassword': '******',
'rpcallowip': '-rpcallowip=1.1.1.1/0.0.0.0',
'rpcservertimeout': '-rpcservertimeout=3600',
'rpcport': '-rpcport=18332'
}
def startd(self):
with open("output_daemon.log","wb") as out:
self.daemon = subprocess.Popen([self.daemon] + list(self.args.values()),stdout=out)
def stopd(self):
self.daemon.terminate()
def set_network_delay(self):
cmds = [
'tc qdisc add ' # Traffic_Control Queue_DISCipline add
' dev eth0 ' # DEVice eth0
' root ' # ROOT_egress_outbound_location
' netem delay 10700ms '
]
subprocess.Popen(cmds[0].split(' '))
def rm_peers(self, node):
return "" # TODO dockercmd.exec_cmd(node, 'rm -f {}/regtest/peers.dat'.format(config.bitcoin_data_dir))
def show_command(self):
print(self.daemon + ' '.join(self.args.values()))
def clean(self):
print("nop")
# -*- coding: utf-8 -*-
# See http://bitcoinlib.readthedocs.io/en/latest/
from bitcoin.rpc import Proxy
from bitcoin.core import b2lx, b2x
rpc = Proxy(btc_conf_file="/Users/sortega/Library/Application Support/Bitcoin/bitcoin.conf")
num_blocks = rpc.getinfo()['blocks']
height = num_blocks / 3
block_id = rpc.getblockhash(height)
block = rpc.getblock(block_id)
last_tx = block.vtx[-1]
print("Last transaction in block %s at height %d" % (b2lx(block_id), height))
print("Raw transaction: %s" % b2x(last_tx.serialize()))
print("Parsed transaction: %s" % last_tx)
class BitcoinNode(Node):
__slots__ = [
'_path', '_spent_to', '_rpc_connection', '_current_tx_chain_index',
'_tx_chains'
]
def __init__(self, name, group, ip, path):
super().__init__(name, group, ip)
self._path = path
self._spent_to = None
self._rpc_connection = None
self._current_tx_chain_index = 0
self._tx_chains = []
def create_conf_file(self):
# file is needed for RPC connection
# reading not possible at each node
# create own file and push
with open(config.btc_conf_file.format(self.name), 'w') as file:
file.write('rpcconnect={}\n'.format(self._ip))
file.write('rpcport={}\n'.format(config.rpc_port))
file.write('rpcuser={}\n'.format(config.rpc_user))
file.write('rpcpassword={}\n'.format(config.rpc_password))
def run(self, connect_to_ips):
bash.check_output(
bitcoincmd.start(self._name, str(self._ip), self._path,
connect_to_ips))
def is_running(self):
return bash.check_output(bitcoincmd.check_if_running(
self._name)) == 'true'
def close_rpc_connection(self):
if self._rpc_connection is not None:
self._rpc_connection.__dict__['_BaseProxy__conn'].close()
logging.debug('Closed rpc')
def stop(self):
self.execute_rpc('stop')
logging.info('stopping node {}'.format(self.name))
def get_log_file(self):
return self._path + config.bitcoin_log_file_name
def wait_until_rpc_ready(self):
while True:
try:
bash.check_output("nc -z -w1 {} {}".format(
self._ip, config.rpc_port))
break
except Exception:
logging.debug("Port not open")
while True:
try:
self.execute_rpc('getnetworkinfo')
break
except JSONRPCError:
logging.debug('RPC not ready yet, sleeping for 2')
utils.sleep(2)
def connect_to_rpc(self):
self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format(
self.name),
timeout=config.rpc_timeout)
def rm_peers_file(self):
return bash.check_output(bitcoincmd.rm_peers(self._name))
def execute_rpc(self, *args):
# No clue whats the optimal
retry = 10
while retry > 0:
try:
return self._rpc_connection.call(args[0], *args[1:])
except (IOError, CannotSendRequest) as error:
logging.exception(
'Error: {}.'
' Reconnecting and retrying, {} more tries left'.format(
error, retry))
retry -= 1
self.connect_to_rpc()
def transfer_coinbases_to_normal_tx(self):
# Readable format convert
for tx_chain in self._tx_chains:
tx_chain.amount /= 2
tx_chain.amount -= int(config.transaction_fee / 2)
raw_transaction = self.execute_rpc(
'createrawtransaction', [{
'txid': tx_chain.current_unspent_tx,
'vout': 0,
}],
OrderedDict([
(tx_chain.address, str(tx_chain.amount / 100000000)),
(self._spent_to.address, str(tx_chain.amount / 100000000))
]))
signed_raw_transaction = self.execute_rpc('signrawtransaction',
raw_transaction)['hex']
tx_chain.current_unspent_tx = self.execute_rpc(
'sendrawtransaction', signed_raw_transaction)
def generate_blocks(self, amount=1):
logging.debug('{} trying to generate mine'.format(self._name))
block_hash = self.execute_rpc('generate', amount)
logging.info('{} mined a block {}'.format(self._name, block_hash))
def generate_tx(self):
# Normal transaction signing and raw processing
tx_chain = self.get_next_tx_chain()
txid = lx(tx_chain.current_unspent_tx)
txins = [
CMutableTxIn(COutPoint(txid, 0)),
CMutableTxIn(COutPoint(txid, 1))
]
txin_seckeys = [tx_chain.seckey, self._spent_to.seckey]
amount_in = tx_chain.amount
tx_chain.amount -= int(config.transaction_fee / 2)
txout1 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(tx_chain.address).to_scriptPubKey())
txout2 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(self._spent_to.address).to_scriptPubKey())
tx = CMutableTransaction(txins, [txout1, txout2], nVersion=2)
for i, txin in enumerate(txins):
txin_scriptPubKey = CScript([
OP_DUP, OP_HASH160,
Hash160(txin_seckeys[i].pub), OP_EQUALVERIFY, OP_CHECKSIG
])
sighash = SignatureHash(txin_scriptPubKey, tx, i, SIGHASH_ALL)
sig = txin_seckeys[i].sign(sighash) + bytes([SIGHASH_ALL])
txin.scriptSig = CScript([sig, txin_seckeys[i].pub])
tx_serialized = tx.serialize()
logging.debug('{} is sending raw transaction'
' (input {} output {} fee {} bytes {})'
' using tx_chain id {}'.format(
self._name, amount_in, txout1.nValue,
(amount_in * 2) - (txout1.nValue * 2),
len(tx_serialized), self._current_tx_chain_index))
tx_hash = self.execute_rpc('sendrawtransaction', b2x(tx_serialized))
tx_chain.current_unspent_tx = tx_hash
#print(tx_chain.current_unspent_tx)
logging.info('{} send was ok; hash={}'.format(self._name, tx_hash))
def generate_spent_to_address(self):
# Get from wallet the list of address or generate one
address = self.execute_rpc('getnewaddress')
seckey = CBitcoinSecret(self.execute_rpc('dumpprivkey', address))
self._spent_to = SpentToAddress(address, seckey)
def create_tx_chains(self):
for unspent_tx in self.execute_rpc('listunspent'):
seckey = CBitcoinSecret(
self.execute_rpc('dumpprivkey', unspent_tx['address']))
tx_chain = TxChain(unspent_tx['txid'], unspent_tx['address'],
seckey, unspent_tx['amount'] * 100000000)
self._tx_chains.append(tx_chain)
def get_next_tx_chain(self):
tx_chain = self._tx_chains[self._current_tx_chain_index]
self._current_tx_chain_index = ((self._current_tx_chain_index + 1) %
len(self._tx_chains))
return tx_chain
async def _cmd_withdraw(client, message, params):
# 「addr」に対して、「amount」XSELを送金します。
if not params[0] == _CMD_STR_WITHDRAW:
return
# Decimalの計算:float禁止
getcontext().traps[FloatOperation] = True
# 引数からdstaddressを取得する。
# ユーザからsrcaddressを取得する。
userid = str(message.author.id)
username = str(message.author)
user_mention = message.author.mention
dst_addr = ""
src_addr = ""
if (len(params) != 3):
await client.send_message(message.channel,
"{0}！書き方がおかしいわね！".format(user_mention))
return
amount = 0
dst_addr = params[1]
if (not dst_addr.startswith("S")):
await client.send_message(message.channel,
"{0}！アドレスがおかしいわね！！".format(user_mention))
return
if (len(dst_addr) != 34):
await client.send_message(message.channel,
"{0}！アドレスがおかしいわね！！".format(user_mention))
return
try:
amount = _round_down8(params[2])
except:
# exceptionで戻る
await client.send_message(
message.channel,
"{0}！amount:{1}が数字じゃないわよ！！".format(user_mention, params[2]))
return
if amount < _round_down8(WITHDRAW_AMOUNT_MIN):
await client.send_message(
message.channel,
"{0}！amount:{1:.8f}が最小値より少ないわ！！".format(user_mention, amount))
return
with closing(sqlite3.connect(DBNAME)) as connection, dblock:
cursor = connection.cursor()
row = dbaccessor.get_user_row(cursor, userid)
if row is not None:
# src アドレス取得
src_addr = row[walletdb.WalletNum.ADDR.value]
src_balance = _round_down8(
str(row[walletdb.WalletNum.BALANCE.value]))
else:
await client.send_message(message.channel,
"{0}！あなたなんて知らないわ！！".format(user_mention))
return
contain_fee = amount + _round_down8(TRANSACTION_FEE)
if src_balance < contain_fee: # 残高がamountより下だったらエラー
await client.send_message(
message.channel,
"{0}！XSELが足りないようね！手数料が{3}必要よ！！balance:{1:.8f} XSEL / amount:{2:.8f} XSEL"
.format(user_mention, src_balance, amount, TRANSACTION_FEE))
return
global last_transaction
if (time.time() - last_transaction) < TRANSACTION_BLANK_TIME:
await client.send_message(
message.channel, "{0}！落ち着いて深呼吸するのよ！！".format(user_mention))
return
sendAmount = amount * COIN
p = Proxy()
try:
transaction = p.sendtoaddress(dst_addr, _str_integer(sendAmount))
last_transaction = time.time()
except bitcoin.rpc.JSONRPCError as ex:
await client.send_message(message.channel,
"{0}！失敗よ！！{1}".format(user_mention, ex))
logger.warning(
"withdraw error id={0} name={1} address={2} amount={3} error={4}"
.format(userid, username, dst_addr, amount, ex))
return
except Exception as ex:
await client.send_message(message.channel,
"{0}！失敗よ！！".format(user_mention))
logger.warning(
"withdraw error id={0} name={1} address={2} amount={3} error={4}"
.format(userid, username, dst_addr, amount, ex))
return
logger.info(
"withdraw id={0} name={1} address={2} amount={3} transaction={4}".
format(userid, username, dst_addr, amount, transaction))
# 送金分を減算
cursor = connection.cursor()
src_after_balance = src_balance - contain_fee
if not dbaccessor.update_balance(cursor, userid, src_after_balance):
logger.error("!!! database unmatched !!!")
await client.send_message(message.channel,
"{0}！失敗したようね！！".format(user_mention))
return
connection.commit()
################################
wd_dst = "**address**\r\n{0}\r\n".format(dst_addr)
wd_am = "**amount**\r\n{0:.8f} XSEL\r\n".format(amount)
wd_tran = "**transaction**\r\n{0}\r\n".format(transaction)
disp_msg = wd_dst + wd_am + wd_tran
await _disp_rep_msg(client, message, username, 'withdraw', disp_msg)
################################
return
import sys
if __name__ == '__main__':
FLAGS = gflags.FLAGS
try:
argv = FLAGS(sys.argv)
except gflags.FlagsError, e:
print '%s\n\nUsage %s ARGS \n%s' % (e, sys.argv[0], FLAGS)
sys.exit(1)
kwargs = {}
kwargs['username'] = FLAGS.username
kwargs['password'] = FLAGS.password
kwargs['timeout'] = FLAGS.timeout
from bitcoin.rpc import Proxy
rpc = Proxy('http://%s:%d/' % (FLAGS.host, FLAGS.port), **kwargs)
engine = create_engine(
os.environ.get('DATABASE_URL',
FLAGS.network.replace('.', '-').join(['sqlite:///','.sqlite'])),
echo = False)
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
Base.metadata.create_all(engine)
session = Session()
chain = session.query(core.Chain).filter_by(name=FLAGS.network).first()
if chain is None:
def _sync_block(self):
p = Proxy()
blockcount = p.getblockcount()
print("sync blockcount = " + str(blockcount))
with closing(sqlite3.connect(self.dbname)) as connection:
cursor = connection.cursor()
checkedcount = self._get_checked_count(cursor)
print("sync checkedcount = " + str(checkedcount))
if checkedcount < CHECKPOINT:
checkedcount = CHECKPOINT
lastblock = blockcount - CONFIRMATIONS
if lastblock <= 0:
return
for i in range(checkedcount + 1, blockcount - CONFIRMATIONS):
if self.stopped:
break
print("sync blockheight = " + str(i))
block = p.getblockbynumber(i)
if block is None:
continue
if BLOCK_KEY_TX not in block.keys():
continue
for transactionid in block[BLOCK_KEY_TX]:
transaction = p.gettransaction(transactionid)
if transaction is None:
continue
if TRANSACTION_KEY_AMOUNT not in transaction.keys():
continue
amount = transaction[TRANSACTION_KEY_AMOUNT]
if amount <= 0:
print("sync amount div")
continue
amount = CWalletSyncher._str_round_down8(amount)
print("sync amount = " + amount)
if TRANSACTION_KEY_DETAILS not in transaction.keys():
print("sync dont have details!!")
continue
print("sync found receive!!")
details = transaction[TRANSACTION_KEY_DETAILS]
for detail in details:
category = detail[TRANSACTION_KEY_CATEGORY]
if (category != TRANSACTION_VALUE_CATEGORY_RECEIVE):
continue
address = detail[TRANSACTION_KEY_ADDRESS]
print("sync receive address = " + address)
with self.dblock:
row = self.dbaccessor.get_user_by_address(
cursor, address)
if row is not None:
height = row[
walletdb.WalletNum.LASTSYNCBLOCK.value]
print("sync receive username = "******" balance = " +
row[walletdb.WalletNum.BALANCE.value] +
" height = " +
str(row[walletdb.WalletNum.LASTSYNCBLOCK.
value]))
src_balance = CWalletSyncher._round_down8(
str(row[walletdb.WalletNum.BALANCE.value]))
dst_balance = src_balance + \
CWalletSyncher._round_down8(amount)
if dst_balance < CWalletSyncher._round_down8(
"0.0"):
dst_balance = CWalletSyncher._round_down8(
"0.0")
print("sync update balance = " +
str(dst_balance) + " amount = " + amount)
if not self.dbaccessor.update_balance_with_blockheight(
cursor,
row[walletdb.WalletNum.ID.value],
dst_balance, i):
print("sync update faild.")
return
self.logger.debug(
"username="******" before=" +
CWalletSyncher._str_round_down8(
src_balance) + " after=" +
CWalletSyncher._str_round_down8(
dst_balance) + " height=" + str(i))
break
pass
self._update_checked_count(cursor, i)
connection.commit()
def test_cannot_validate(self):
if False:
non_working_address = 'LTatMHrYyHcxhxrY27AqFN53bT4TauR86h'
p = Proxy()
r = p.validateAddress(non_working_address)
self.assertEqual(r['isvalid'], False)
#!/usr/bin/env python
import codecs
from bitcoin.rpc import Proxy
if __name__ == '__main__':
url = raw_input('Please enter the RPC url: ')
username = raw_input('Please enter the RPC username: '******'Please enter the RPC password: '******'out.csv', 'w', 'utf-8')
for idx in xrange(numblocks):
blockinfo = proxy.getblock(proxy.getblockhash(idx))
fp.write(','.join(
map(str, [
blockinfo['height'],
blockinfo['time'],
blockinfo['difficulty'],
])) + '\n')
fp.close()
def __init__(self, **kwargs):
nmc_conf_file = os.path.expanduser('~/.namecoin/namecoin.conf')
Proxy.__init__(self, btc_conf_file=nmc_conf_file, **kwargs)
