def setup_api_client(self, api_key=None, api_secret=None, debug=True):
if api_key is None:
api_key = os.environ.get('BLOCKTRAIL_SDK_APIKEY',
'EXAMPLE_BLOCKTRAIL_SDK_PYTHON_APIKEY')
if api_secret is None:
api_secret = os.environ.get(
'BLOCKTRAIL_SDK_APISECRET',
'EXAMPLE_BLOCKTRAIL_SDK_PYTHON_APISECRET')
return blocktrail.APIClient(api_key, api_secret, debug=debug)
from __future__ import print_function
import blocktrail
from blocktrail.exceptions import ObjectNotFound
client = blocktrail.APIClient("MY_APIKEY", "MY_APISECRET", testnet=True)
try:
wallet = client.init_wallet("example-wallet", "example-strong-password")
except ObjectNotFound:
wallet, primary_mnemonic, backup_mnemonic, blocktrail_pubkeys = client.create_new_wallet(
"example-wallet", "example-strong-password", key_index=9999)
wallet.do_discovery()
print(wallet.get_new_address_pair())
print(wallet.get_balance())
path, address = wallet.get_new_address_pair()
print(wallet.pay([(address, blocktrail.to_satoshi(0.001))]))
from __future__ import print_function
import os
import glob
from time import sleep
import blocktrail
while True:
try:
client = blocktrail.APIClient(api_key="731ac7a92afe05e7640b3e89d69ecce514d3ea1d", api_secret="cb816f06d9722244f7489deb71cc65c43b97bccd", network="BTC", testnet=False)
# address = client.address('3ETGrUjxeuC1e8nY8EP7U2EUcvffX76AKC')
try:
newest = max(glob.iglob('*.json'))
prev_block = int(os.path.splitext(newest)[0])
except ValueError as e:
print(e)
prev_block = 0
print('Last block at the system: %s' % str(prev_block))
print('Pause before the main loop... :)')
sleep(10)
while True:
latest_block = client.block_latest()
last_block = latest_block['height']
for i in xrange(prev_block, last_block):
try:
b = client.block(i)
class SpoolAction(Task):
abstract = True
spool = None
transactions = None
# initialize if BTC is enabled
if settings.BTC_ENABLED:
logger.info('Using service: {}'.format(settings.BTC_SERVICE))
spool = BackendSpool(service=settings.BTC_SERVICE,
username=settings.BTC_USERNAME,
password=settings.BTC_PASSWORD,
host=settings.BTC_HOST,
port=settings.BTC_PORT,
testnet=settings.BTC_TESTNET,
fee=settings.BTC_FEE,
token=settings.BTC_TOKEN)
transactions = spool._t
# blocktrail client
blocktrail_client = blocktrail.APIClient(
api_key=settings.BLOCKTRAIL_API_KEY,
api_secret=settings.BLOCKTRAIL_API_SECRET,
testnet=settings.BTC_TESTNET)
def __call__(self, *args, **kwargs):
# we will catch exceptions here, analyse them and decide what to do later
try:
# call only if btc is enabled
if settings.BTC_ENABLED:
return super(SpoolAction, self).__call__(*args, **kwargs)
else:
logger.info('BTC_ENABLED is False. Skipping: {}'.format(
self.name))
except Exception as e:
# TODO: Log exception
print e
if super(SpoolAction, self).__name__ not in [
'monitor', 'do_transaction', 'monitor_refill',
'transaction_monitor', 'initialize'
]:
countdown = randint(100, 120)
logger.info('retrying task {} in {}s'.format(
super(SpoolAction, self).__name__, countdown))
self.retry(exc=e, countdown=countdown, max_retries=5)
else:
raise
def after_return(self, status, retval, task_id, args, kwargs, einfo):
pass
def on_failure(self, exc, task_id, args, kwargs, einfo):
analyser.apply_async((exc, task_id, args, kwargs, einfo))
def on_retry(self, exc, task_id, args, kwargs, einfo):
pass
def on_success(self, retval, task_id, args, kwargs):
# call subscribe to blocktrail event
if settings.BTC_ENABLED and self.name not in [
'bitcoin.tasks.transaction_monitor',
'bitcoin.tasks.check_status',
'bitcoin.tasks.refill_main_wallet', 'bitcoin.tasks.initialize',
'bitcoin.tasks.initialize_federation_wallet',
'bitcoin.tasks.import_addresses',
'bitcoin.tasks.import_address',
'bitcoin.tasks.create_refill_chunks'
]:
self.blocktrail_subscribe(retval)
def blocktrail_subscribe(self, txid):
logger.info('Subscribing to events on {}'.format(txid))
self.blocktrail_client.subscribe_transaction(
identifier='confirmations', transaction=txid, confirmations=1)
def blocktrail_unsubscribe(self, txid):
logger.info('Unsubscribing to events on {}'.format(txid))
try:
self.blocktrail_client.unsubscribe_transaction(
identifier='confirmations', transaction=txid)
except blocktrail.exceptions.ObjectNotFound:
logger.info('{} webhook not found'.format(txid))
def select_chunk(self):
"""
Select chunk to refill_main_wallet with a locked table to avoid race conditions
"""
print 'selecting chunks'
cursor = connection.cursor()
cursor.execute(query_sql_refill)
desc = cursor.description
unspents = [
dict(zip([col[0] for col in desc], row))
for row in cursor.fetchall()
]
if len(unspents) == 0:
raise SpoolFundsError('Not enough unspents for transaction')
chunks = filter(lambda d: d['amount'] == settings.BTC_CHUNK, unspents)
return chunks
from __future__ import print_function
import blocktrail
client = blocktrail.APIClient("YOUR_APIKEY_HERE", "YOUR_APISECRET_HERE")
address = client.address("1dice8EMZmqKvrGE4Qc9bUFf9PX3xaYDp")
print(address['address'], address['balance'])
print(
len(
client.address_transactions("1dice8EMZmqKvrGE4Qc9bUFf9PX3xaYDp")
['data']))
print(
client.verify_address(
"16dwJmR4mX5RguGrocMfN9Q9FR2kZcLw2z",
"HPMOHRgPSMKdXrU6AqQs/i9S7alOakkHsJiqLGmInt05Cxj6b/WhS7kJxbIQxKmDW08YKzoFnbVZIoTI2qofEzk="
))
# Dealing with numbers
print("123456789 Satoshi to BTC: ", blocktrail.to_btc(123456789))
print("1.23456789 BTC to Satoshi: ", blocktrail.to_satoshi(1.23456789))
def main():
parser = argparse.ArgumentParser(
description="Process blinktrade withdrawals requests")
parser.add_argument('-c',
"--config",
action="store",
dest="config",
help='Configuration file',
type=str)
arguments = parser.parse_args()
candidates = [
os.path.join(site_config_dir('blinktrade'),
'blinktrade_withdrawer.ini'),
os.path.expanduser('~/.blinktrade/blinktrade_withdrawer.ini')
]
if arguments.config:
candidates.append(arguments.config)
config = ConfigParser.SafeConfigParser()
config.read(candidates)
password = getpass.getpass('password: '******'ws':
should_connect_on_ssl = False
blinktrade_port = 80
db_engine = config.get("database", "sqlalchemy_engine") + ':///' +\
os.path.expanduser(config.get("database", "sqlalchemy_connection_string"))
engine = create_engine(db_engine,
echo=config.getboolean('database',
'sqlalchmey_verbose'))
Base.metadata.create_all(engine)
factory = BlinkTradeClientFactory(blinktrade_url.geturl())
factory.db_session = scoped_session(sessionmaker(bind=engine))
factory.verbose = config.getboolean("blinktrade", "verbose")
factory.blinktrade_broker_id = config.get("blinktrade", "broker_id")
factory.blinktrade_user = config.get("blinktrade", "api_key")
factory.blinktrade_password = decrypt(
password, unhexlify(config.get("blinktrade", "api_password")))
factory.currencies = json.loads(config.get("blinktrade", "currencies"))
factory.methods = json.loads(config.get("blinktrade", "methods"))
factory.blocked_accounts = json.loads(
config.get("blinktrade", "blocked_accounts"))
factory.mandrill_api = mandrill_api
if config.has_section('blockchain_info'):
from blockchain_info import BlockchainInfoWithdrawalProtocol
factory.blockchain_guid = decrypt(
password, unhexlify(config.get("blockchain_info", "guid")))
factory.blockchain_main_password = decrypt(
password, unhexlify(config.get("blockchain_info",
"main_password")))
factory.blockchain_second_password = decrypt(
password,
unhexlify(config.get("blockchain_info", "second_password")))
factory.blockchain_api_key = config.get("blockchain_info", "api_key")
factory.from_address = config.get("blockchain_info", "from_address")
factory.note = config.get("blockchain_info", "note")
factory.protocol = BlockchainInfoWithdrawalProtocol
if config.has_section('blocktrail'):
import blocktrail
from mnemonic.mnemonic import Mnemonic
from pycoin.key.BIP32Node import BIP32Node
is_testnet = False
if config.get("blocktrail", "testnet") == '1':
is_testnet = True
client = blocktrail.APIClient(
api_key=config.get("blocktrail", "api_key"),
api_secret=decrypt(
password, unhexlify(config.get("blocktrail", "api_secret"))),
network='BTC',
testnet=is_testnet)
data = client.get_wallet(config.get("blocktrail", "wallet_identifier"))
primary_seed = Mnemonic.to_seed(
data['primary_mnemonic'],
decrypt(password,
unhexlify(config.get("blocktrail", "wallet_passphrase"))))
primary_private_key = BIP32Node.from_master_secret(
primary_seed, netcode='XTN' if client.testnet else 'BTC')
backup_public_key = BIP32Node.from_hwif(data['backup_public_key'][0])
checksum = client.create_checksum(primary_private_key)
if checksum != data['checksum']:
raise Exception("Checksum [%s] does not match expected checksum [%s], " \
"most likely due to incorrect password" % (checksum, data['checksum']))
blocktrail_public_keys = {}
for v, k in data['blocktrail_public_keys']:
if k in blocktrail_public_keys:
blocktrail_public_keys[k].append(v)
else:
blocktrail_public_keys[k] = [v]
key_index = data['key_index']
wallet = blocktrail.wallet.Wallet(
client=client,
identifier=config.get("blocktrail", "wallet_identifier"),
primary_mnemonic=data['primary_mnemonic'],
primary_private_key=primary_private_key,
backup_public_key=backup_public_key,
blocktrail_public_keys=blocktrail_public_keys,
key_index=key_index,
testnet=client.testnet)
from blocktrail_protocol import BlocktrailWithdrawalProtocol
factory.blocktrail_wallet = wallet
factory.blocktrail_change_address = config.get("blocktrail",
"change_address")
factory.protocol = BlocktrailWithdrawalProtocol
if config.has_section('mailer'):
from mailer_protocol import MailerWithdrawalProtocol
factory.mandrill_apikey = config.get("mailer", "mandrill_apikey")
factory.mandrill_template_name = config.get("mailer", "template_name")
factory.mandrill_from_email = config.get("mailer", "from_email")
factory.mandrill_from_name = config.get("mailer", "from_name")
factory.mandrill_to_email = config.get("mailer", "to_email")
factory.mandrill_to_name = config.get("mailer", "to_name")
factory.mandrill_website = config.get("mailer", "website")
factory.protocol = MailerWithdrawalProtocol
if should_connect_on_ssl:
reactor.connectSSL(blinktrade_url.netloc, blinktrade_port, factory,
ssl.ClientContextFactory())
else:
reactor.connectTCP(blinktrade_url.netloc, blinktrade_port, factory)
reactor.run()
import os
import blocktrail
import json
import sys
from utils import *
FETCH_HISTORY = 'FETCH_HISTORY'
if __name__ == '__main__':
client = blocktrail.APIClient(api_key=os.environ['BLOCKTRAIL_KEY'],
api_secret=os.environ['BLOCKTRAIL_SECRET'],
network="BTC",
testnet=False)
block_hash = ''
prev_block_hash = ''
block = None
blocks = {'fetch_next': None, 'fetched': []}
if not os.path.exists(FETCH_HISTORY) or len(sys.argv) > 1:
block = client.block_latest()
block_hash = block['hash']
else:
with open(FETCH_HISTORY) as fin:
blocks = json.loads(fin.read().strip())
block = client.block(blocks['fetch_next'])
per_page = 100
page = 1
print("Fetching transactions for block", block['hash'])
print("There are a total of %d transactions in this block" %
block['transactions'])
from django.conf import settings
from getenv import env
import blocktrail
#Blocktrail API config
NETWORK = env('NETWORK','BTC')
TESTNET = env('TESTNET', True)
#Blocktrail webhook
IDENTIFIER = "towan"
CONFIRMATIONS = 0
client = blocktrail.APIClient(api_key=settings.MY_APIKEY, api_secret=settings.MY_APISECRET, network=NETWORK, testnet=TESTNET)
def subscribe_address_event(address):
""" Suscribe to blocktrail transaction event webhook on address """
try:
client.subscribe_address_transactions(identifier=IDENTIFIER, address=address, confirmations=CONFIRMATIONS)
except Exception as e:
print '%s (%s)' % (e.message, type(e))
def unsubscribe_address_event(address):
""" Unsuscribe to blocktrail transaction event webhook on address """
try:
client.unsubscribe_address_transactions(identifier=IDENTIFIER, address=address)
except Exception as e:
print '%s (%s)' % (e.message, type(e))