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 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 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 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 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)
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 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__(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 __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 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
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
# -*- 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)
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 __init__(self):
self.bitcoin_proxy = Proxy()
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
def connect_to_rpc(self):
self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format(
self.name),
timeout=config.rpc_timeout)
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):
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).
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()
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()
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()
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
def __init__(self):
self.proxy = Proxy('http://*****:*****@blockchain.infnote.com:8962')
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()
#!/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 issue_op_return(conf, op_return_bstring):
print('\nConfigured values are:\n')
print('working_directory:\t{}'.format(conf.working_directory))
print('issuing_address:\t{}'.format(conf.issuing_address))
print('full_node_url:\t\t{}'.format(conf.full_node_url))
print('full_node_rpc_user:\t{}'.format(conf.full_node_rpc_user))
print('testnet:\t\t{}'.format(conf.testnet))
print('tx_fee_per_byte:\t{}'.format(conf.tx_fee_per_byte))
print('Bytes for OP_RETURN:\n{}'.format(op_return_bstring))
print('Hex for OP_RETURN:\n{}'.format(binascii.hexlify(op_return_bstring)))
op_return_cert_protocol = op_return_bstring
consent = input('Do you want to continue? [y/N]: ').lower() in ('y', 'yes')
if not consent:
sys.exit()
full_node_rpc_password = getpass.getpass(
'\nPlease enter the password for the node\'s RPC user: '******'testnet')
else:
SelectParams('mainnet')
proxy = Proxy("http://{0}:{1}@{2}".format(conf.full_node_rpc_user,
full_node_rpc_password,
conf.full_node_url))
# create transaction
tx_outputs = []
unspent = sorted(proxy.listunspent(1, 9999999, [conf.issuing_address]),
key=lambda x: hash(x['amount']),
reverse=True)
issuing_pubkey = proxy.validateaddress(conf.issuing_address)['pubkey']
tx_inputs = [CMutableTxIn(unspent[0]['outpoint'])]
input_amount = unspent[0]['amount']
change_script_out = CBitcoinAddress(conf.issuing_address).to_scriptPubKey()
change_output = CMutableTxOut(input_amount, change_script_out)
op_return_output = CMutableTxOut(
0, CScript([OP_RETURN, op_return_cert_protocol]))
tx_outputs = [change_output, op_return_output]
tx = CMutableTransaction(tx_inputs, tx_outputs)
# sign transaction to get its size
r = proxy.signrawtransaction(tx)
assert r['complete']
signed_tx = r['tx']
signed_tx_size = len(signed_tx.serialize())
# calculate fees and change
tx_fee = signed_tx_size * conf.tx_fee_per_byte
change_amount = input_amount - tx_fee
if (change_amount < 0):
sys.exit(
"Specified address cannot cover the transaction fee of: {} satoshis"
.format(tx_fee))
# update tx out for change and re-sign
tx.vout[0].nValue = change_amount
r = proxy.signrawtransaction(tx)
assert r['complete']
signed_tx = r['tx']
# send transaction
print('The fee will be {} satoshis.\n'.format(tx_fee))
consent = input(
'Do you want to issue on the blockchain? [y/N]: ').lower() in ('y',
'yes')
if not consent:
sys.exit()
tx_id = b2lx(proxy.sendrawtransaction(signed_tx))
return tx_id
