#! /usr/bin/env python3

import os

import argparse

import json

import decimal

import sys

import logging

import unicodedata

import time

import dateutil.parser

import calendar

import configparser

from threading import Thread

import requests

import appdirs

from prettytable import PrettyTable

from lib import (config, api, util, exceptions, bitcoin, blocks)

if os.name == 'nt':

from lib import util_windows

D = decimal.Decimal

json_print = lambda x: print(json.dumps(x, sort_keys=True, indent=4))

def format_order (order):

return [D(give_remaining), give_asset, price, price_assets, str(order['fee_required'] / config.UNIT), str(order['fee_provided'] / config.UNIT), order['expire_index'] - util.last_block(db)['block_index'], order['tx_hash']]

def format_bet (bet):

return [util.BET_TYPE_NAME[bet['bet_type']], bet['feed_address'], util.isodt(bet['deadline']), target_value, leverage, str(bet['wager_remaining'] / config.UNIT) + ' XCP', util.devise(db, odds, 'odds', 'output'), bet['expire_index'] - util.last_block(db)['block_index'], bet['tx_hash']]

def format_order_match (db, order_match):

order_match_id = order_match['tx0_hash'] + order_match['tx1_hash']

order_match_time_left = order_match['match_expire_index'] - util.last_block(db)['block_index']

return [order_match_id, order_match_time_left]

def format_feed (feed):

return [feed['source'], timestamp, text, feed['value'], D(feed['fee_fraction_int']) / D(1e8)]

def market (give_asset, get_asset):

print(table)

def cli(method, params, unsigned):

sys.exit(1)

def set_options (data_dir=None,

config.UNSPENDABLE = '1CounterpartyXXXXXXXXXXXXXXXUWLpVr'

def balances (address):

print(table.get_string())

if __name__ == '__main__':

if os.name == 'nt':

#patch up cmd.exe's "challenged" (i.e. broken/non-existent) UTF-8 logging

util_windows.fix_win32_unicode()

# Parse command-line arguments.

parser = argparse.ArgumentParser(prog='counterpartyd', description='the reference implementation of the Counterparty protocol')

parser.add_argument('-V', '--version', action='version', version="counterpartyd v%s" % config.CLIENT_VERSION_STRING)

parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='sets log level to DEBUG instead of WARNING')

parser.add_argument('--force', action='store_true', help='don\'t check whether Bitcoind is caught up')

parser.add_argument('--testnet', action='store_true', help='use Bitcoin testnet addresses and block numbers')

parser.add_argument('--testcoin', action='store_true', help='use the test Counterparty network on every blockchain')

parser.add_argument('--unsigned', action='store_true', default=False, help='print out unsigned hex of transaction; do not sign or broadcast')

parser.add_argument('--careful', action='store_true', default=False, help='check conservation of assets')

parser.add_argument('--no-interaction', action='store_true', default=False, help='do not request user confirmation before signing and broadcasting')

parser.add_argument('--data-dir', help='the directory in which to keep the database, config file and log file, by default')

parser.add_argument('--database-file', help='the location of the SQLite3 database')

parser.add_argument('--config-file', help='the location of the configuration file')

parser.add_argument('--log-file', help='the location of the log file')

parser.add_argument('--pid-file', help='the location of the pid file')

parser.add_argument('--api-num-threads', help='the number of threads created for API request processing (CherryPy WSGI, default 10)')

parser.add_argument('--api-request-queue-size', help='the size of the API request queue (CherryPY WSGI, default 5)')

parser.add_argument('--bitcoind-rpc-connect', help='the hostname or IP of the bitcoind JSON-RPC server')

parser.add_argument('--bitcoind-rpc-port', type=int, help='the bitcoind JSON-RPC port to connect to')

parser.add_argument('--bitcoind-rpc-user', help='the username used to communicate with Bitcoind over JSON-RPC')

parser.add_argument('--bitcoind-rpc-password', help='the password used to communicate with Bitcoind over JSON-RPC')

parser.add_argument('--insight-enable', action='store_true', default=False, help='enable the use of insight, instead of blockchain.info')

parser.add_argument('--insight-connect', help='the insight server hostname or IP to connect to')

parser.add_argument('--insight-port', type=int, help='the insight server port to connect to')

parser.add_argument('--rpc-host', help='the IP of the interface to bind to for providing JSON-RPC API access (0.0.0.0 for all interfaces)')

parser.add_argument('--rpc-port', type=int, help='port on which to provide the counterpartyd JSON-RPC API')

parser.add_argument('--rpc-user', help='required username to use the counterpartyd JSON-RPC API (via HTTP basic auth)')

parser.add_argument('--rpc-password', help='required password (for rpc-user) to use the counterpartyd JSON-RPC API (via HTTP basic auth)')

subparsers = parser.add_subparsers(dest='action', help='the action to be taken')

parser_server = subparsers.add_parser('server', help='run the server (WARNING: not thread‐safe)')

parser_send = subparsers.add_parser('send', help='create and broadcast a *send* message')

parser_send.add_argument('--source', required=True, help='the source address')

parser_send.add_argument('--destination', required=True, help='the destination address')

parser_send.add_argument('--quantity', required=True, help='the quantity of ASSET to send')

parser_send.add_argument('--asset', required=True, help='the ASSET of which you would like to send QUANTITY')

parser_order = subparsers.add_parser('order', help='create and broadcast an *order* message')

parser_order.add_argument('--source', required=True, help='the source address')

parser_order.add_argument('--get-quantity', required=True, help='the quantity of GET_ASSET that you would like to receive')

parser_order.add_argument('--get-asset', required=True, help='the asset that you would like to buy')

parser_order.add_argument('--give-quantity', required=True, help='the quantity of GIVE_ASSET that you are willing to give')

parser_order.add_argument('--give-asset', required=True, help='the asset that you would like to sell')

parser_order.add_argument('--expiration', type=int, required=True, help='the number of blocks for which the order should be valid')

parser_order.add_argument('--fee-fraction-required', default=config.FEE_FRACTION_REQUIRED_DEFAULT, help='the miners’ fee required for an order to match this one, as a fraction of the BTC to be bought')

parser_order.add_argument('--fee-fraction-provided', default=config.FEE_FRACTION_PROVIDED_DEFAULT, help='the miners’ fee provided, as a fraction of the BTC to be sold')

parser_btcpay= subparsers.add_parser('btcpay', help='create and broadcast a *BTCpay* message, to settle an Order Match for which you owe BTC')

parser_btcpay.add_argument('--order-match-id', required=True, help='the concatenation of the hashes of the two transactions which compose the order match')

parser_issuance = subparsers.add_parser('issuance', help='issue a new asset, issue more of an existing asset or transfer the ownership of an asset')

parser_issuance.add_argument('--source', required=True, help='the source address')

parser_issuance.add_argument('--transfer-destination', help='for transfer of ownership of asset issuance rights')

parser_issuance.add_argument('--quantity', default=0, help='the quantity of ASSET to be issued')

parser_issuance.add_argument('--asset', required=True, help='the name of the asset to be issued (if it’s available)')

parser_issuance.add_argument('--divisible', action='store_true', help='whether or not the asset is divisible (must agree with previous issuances)')

parser_issuance.add_argument('--callable', dest='callable_', action='store_true', help='whether or not the asset is callable (must agree with previous issuances)')

parser_issuance.add_argument('--call-date', help='the date from which a callable asset may be called back (must agree with previous issuances)')

parser_issuance.add_argument('--call-price', help='the price, in XCP per whole unit, at which a callable asset may be called back (must agree with previous issuances)')

parser_issuance.add_argument('--description', type=str, required=True, help='a description of the asset (set to ‘LOCK’ to lock against further issuances with non‐zero quantitys)')

parser_broadcast = subparsers.add_parser('broadcast', help='broadcast textual and numerical information to the network')

parser_broadcast.add_argument('--source', required=True, help='the source address')

parser_broadcast.add_argument('--text', type=str, required=True, help='the textual part of the broadcast (set to ‘LOCK’ to lock feed)')

parser_broadcast.add_argument('--value', type=float, default=-1, help='numerical value of the broadcast')

parser_broadcast.add_argument('--fee-fraction', default=0, help='the fraction of bets on this feed that go to its operator')

parser_bet = subparsers.add_parser('bet', help='offer to make a bet on the value of a feed')

parser_bet.add_argument('--source', required=True, help='the source address')

parser_bet.add_argument('--feed-address', required=True, help='the address which publishes the feed to bet on')

parser_bet.add_argument('--bet-type', choices=list(util.BET_TYPE_NAME.values()), required=True, help='choices: {}'.format(list(util.BET_TYPE_NAME.values())))

parser_bet.add_argument('--deadline', required=True, help='the date and time at which the bet should be decided/settled')

parser_bet.add_argument('--wager', required=True, help='the quantity of XCP to wager')

parser_bet.add_argument('--counterwager', required=True, help='the minimum quantity of XCP to be wagered by the user to bet against you, if he were to accept the whole thing')

parser_bet.add_argument('--target-value', default=0.0, help='target value for Equal/NotEqual bet')

parser_bet.add_argument('--leverage', type=int, default=5040, help='leverage, as a fraction of 5040')

parser_bet.add_argument('--expiration', type=int, required=True, help='the number of blocks for which the bet should be valid')

parser_dividend = subparsers.add_parser('dividend', help='pay dividends to the holders of an asset (in proportion to their stake in it)')

parser_dividend.add_argument('--source', required=True, help='the source address')

parser_dividend.add_argument('--quantity-per-unit', required=True, help='the quantity of XCP to be paid per whole unit held of ASSET')

parser_dividend.add_argument('--asset', required=True, help='the asset to which pay dividends')

parser_dividend.add_argument('--dividend-asset', required=True, help='asset in which to pay the dividends')

parser_burn = subparsers.add_parser('burn', help='destroy bitcoins to earn XCP, during an initial period of time')

parser_burn.add_argument('--source', required=True, help='the source address')

parser_burn.add_argument('--quantity', required=True, help='quantity of BTC to be destroyed')

parser_cancel= subparsers.add_parser('cancel', help='cancel an open order or bet you created')

parser_cancel.add_argument('--offer-hash', required=True, help='the transaction hash of the order or bet')

parser_callback = subparsers.add_parser('callback', help='callback a fraction of an asset')

parser_callback.add_argument('--source', required=True, help='the source address')

parser_callback.add_argument('--fraction', required=True, help='the fraction of ASSET to call back')

parser_callback.add_argument('--asset', required=True, help='the asset to callback')

parser_address = subparsers.add_parser('balances', help='display the balances of a Counterparty address')

parser_address.add_argument('address', help='the address you are interested in')

parser_asset = subparsers.add_parser('asset', help='display the basic properties of a Counterparty asset')

parser_asset.add_argument('asset', help='the asset you are interested in')

parser_wallet = subparsers.add_parser('wallet', help='list the addresses in your Bitcoind wallet along with their balances in all Counterparty assets')

parser_pending= subparsers.add_parser('pending', help='list pending order matches awaiting BTCpayment from you')

parser_reparse = subparsers.add_parser('reparse', help='reparse all transactions in the database (WARNING: not thread‐safe)')

parser_rollback = subparsers.add_parser('rollback', help='rollback database (WARNING: not thread‐safe)')

parser_rollback.add_argument('block_index', type=int, help='the index of the last known good block')

parser_market = subparsers.add_parser('market', help='fill the screen with an always up-to-date summary of the Counterparty market')

parser_market.add_argument('--give-asset', help='only show orders offering to sell GIVE_ASSET')

parser_market.add_argument('--get-asset', help='only show orders offering to buy GET_ASSET')

"""

parser_checksum = subparsers.add_parser('checksum', help='create an asset name from a base string')

parser_checksum.add_argument('string', help='base string of the desired asset name')

"""

args = parser.parse_args()

# Configuration

set_options(data_dir=args.data_dir,

bitcoind_rpc_connect=args.bitcoind_rpc_connect, bitcoind_rpc_port=args.bitcoind_rpc_port,

bitcoind_rpc_user=args.bitcoind_rpc_user, bitcoind_rpc_password=args.bitcoind_rpc_password,

insight_enable=args.insight_enable, insight_connect=args.insight_connect, insight_port=args.insight_port,

rpc_host=args.rpc_host, rpc_port=args.rpc_port, rpc_user=args.rpc_user, rpc_password=args.rpc_password,

log_file=args.log_file, pid_file=args.pid_file,

api_num_threads=args.api_num_threads, api_request_queue_size=args.api_request_queue_size,

database_file=args.database_file, testnet=args.testnet, testcoin=args.testcoin, unittest=False, careful=args.careful, no_interaction=args.no_interaction)

#Create/update pid file

pid = str(os.getpid())

pidf = open(config.PID, 'w')

pidf.write(pid)

pidf.close()

# Database

db = util.connect_to_db()

# Logging (to file and console).

logger = logging.getLogger() #get root logger

logger.setLevel(logging.DEBUG if args.verbose else logging.INFO)

#Console logging

console = logging.StreamHandler()

console.setLevel(logging.DEBUG if args.verbose else logging.INFO)

formatter = logging.Formatter('%(message)s')

console.setFormatter(formatter)

logger.addHandler(console)

#File logging (rotated)

max_log_size = 2 * 1024 * 1024 #max log size of 2 MB before rotation (make configurable later)

if os.name == 'nt':

fileh = util_windows.SanitizedRotatingFileHandler(config.LOG, maxBytes=max_log_size, backupCount=5)

else:

fileh = logging.handlers.RotatingFileHandler(config.LOG, maxBytes=max_log_size, backupCount=5)

fileh.setLevel(logging.DEBUG if args.verbose else logging.INFO)

formatter = logging.Formatter('%(asctime)s %(message)s', '%Y-%m-%d-T%H:%M:%S%z')

fileh.setFormatter(formatter)

logger.addHandler(fileh)

#API requests logging (don't show on console in normal operation)

requests_log = logging.getLogger("requests")

requests_log.setLevel(logging.DEBUG if args.verbose else logging.WARNING)

if args.action == None: args.action = 'server'

# TODO

# Check versions.

# Check that bitcoind is running, communicable, and caught up with the blockchain.

# Check that the database has caught up with bitcoind.

if not args.force:

util.versions_check(db)

bitcoin.bitcoind_check(db)

if args.action not in ('server', 'reparse', 'rollback'):

util.database_check(db, bitcoin.get_block_count())

# TODO

# Do something.

# MESSAGE CREATION

if args.action == 'send':

quantity = util.devise(db, args.quantity, args.asset, 'input')

cli('create_send', [args.source, args.destination, args.asset,

quantity],

args.unsigned)

elif args.action == 'order':

fee_required, fee_fraction_provided = D(args.fee_fraction_required), D(args.fee_fraction_provided)

give_quantity, get_quantity = D(args.give_quantity), D(args.get_quantity)

# Fee argument is either fee_required or fee_provided, as necessary.

if args.give_asset == 'BTC':

fee_required = 0

fee_fraction_provided = util.devise(db, fee_fraction_provided, 'fraction', 'input')

fee_provided = round(D(fee_fraction_provided) * D(give_quantity) * D(config.UNIT))

if fee_provided < config.MIN_FEE:

raise exceptions.InputError('Fee provided less than minimum necessary for acceptance in a block.')

print('Fee provided: {} BTC'.format(util.devise(db, fee_provided, 'BTC', 'output')))

elif args.get_asset == 'BTC':

fee_provided = config.MIN_FEE

fee_fraction_required = util.devise(db, args.fee_fraction_required, 'fraction', 'input')

fee_required = round(D(fee_fraction_required) * D(get_quantity) * D(config.UNIT))

print('Fee required: {} BTC'.format(util.devise(db, fee_required, 'BTC', 'output')))

else:

fee_required = 0

fee_provided = config.MIN_FEE

give_quantity = util.devise(db, give_quantity, args.give_asset, 'input')

get_quantity = util.devise(db, get_quantity, args.get_asset, 'input')

cli('create_order', [args.source, args.give_asset, give_quantity,

args.get_asset, get_quantity, args.expiration,

fee_required, fee_provided],

args.unsigned)

elif args.action == 'btcpay':

cli('create_btcpay', [args.order_match_id], args.unsigned)

elif args.action == 'issuance':

quantity = util.devise(db, args.quantity, None, 'input',

divisible=args.divisible)

if args.callable_:

if not args.call_date:

parser.error('must specify call date of callable asset', )

if not args.call_price:

parser.error('must specify call price of callable asset')

call_date = calendar.timegm(dateutil.parser.parse(args.call_date).utctimetuple())

call_price = float(args.call_price)

else:

call_date, call_price = 0, 0

cli('create_issuance', [args.source, args.asset, quantity,

args.divisible, args.description,

args.callable_, call_date, call_price,

args.transfer_destination],

args.unsigned)

elif args.action == 'broadcast':

value = util.devise(db, args.value, 'value', 'input')

fee_fraction = util.devise(db, args.fee_fraction, 'fraction', 'input')

cli('create_broadcast', [args.source, fee_fraction, args.text,

int(time.time()), value],

args.unsigned)

elif args.action == 'bet':

deadline = calendar.timegm(dateutil.parser.parse(args.deadline).utctimetuple())

wager = util.devise(db, args.wager, 'XCP', 'input')

counterwager = util.devise(db, args.counterwager, 'XCP', 'input')

target_value = util.devise(db, args.target_value, 'value', 'input')

leverage = util.devise(db, args.leverage, 'leverage', 'input')

cli('create_bet', [args.source, args.feed_address, args.bet_type,

deadline, wager, counterwager, args.expiration,

target_value, leverage],

args.unsigned)

elif args.action == 'dividend':

quantity_per_unit = util.devise(db, args.quantity_per_unit, 'XCP', 'input')

cli('create_dividend', [args.source, quantity_per_unit, args.asset, args.dividend_asset],

args.unsigned)

elif args.action == 'burn':

quantity = util.devise(db, args.quantity, 'BTC', 'input')

cli('create_burn', [args.source, quantity], args.unsigned)

elif args.action == 'cancel':

cli('create_cancel', [args.offer_hash], args.unsigned)

elif args.action == 'callback':

cli('create_callback', [args.source, util.devise(db, args.fraction,

'fraction', 'input'), args.asset],

args.unsigned)

# VIEWING (temporary)

elif args.action == 'balances':

try:

bitcoin.base58_decode(args.address, config.ADDRESSVERSION)

except Exception:

raise exceptions.InvalidAddressError('Invalid Bitcoin address:',

args.address)

balances(args.address)

elif args.action == 'asset':

results = util.api('get_asset_info', ([args.asset],))[0] # HACK

asset_id = util.get_asset_id(args.asset)

divisible = results['divisible']

total_issued = util.devise(db, results['total_issued'], args.asset, dest='output')

call_date = util.isodt(results['call_date']) if results['call_date'] else results['call_date']

call_price = str(results['call_price']) + ' XCP' if results['call_price'] else results['call_price']

print('Asset Name:', args.asset)

print('Asset ID:', asset_id)

print('Divisible:', divisible)

print('Total Issued:', total_issued)

print('Issuer:', results['issuer'])

print('Callable:', results['callable'])

print('Call Date:', call_date)

print('Call Price:', call_price)

print('Description:', '‘' + results['description'] + '’')

print('Shareholders:')

balances = util.get_balances(db, asset=args.asset) # + util.get_escrowed(db, asset=asset)

print('\taddress, quantity, escrow')

for holder in util.get_holders(db, args.asset):

quantity = holder['address_quantity']

if not quantity: continue

quantity = util.devise(db, quantity, args.asset, 'output')

if holder['escrow']: escrow = holder['escrow']

else: escrow = 'None'

print('\t' + str(holder['address']) + ',' + str(quantity) + ',' + escrow)

elif args.action == 'wallet':

total_table = PrettyTable(['Asset', 'Balance'])

totals = {}

print()

for bunch in bitcoin.get_wallet():

address, btc_balance = bunch[:2]

get_address = util.get_address(db, address=address)

balances = get_address['balances']

table = PrettyTable(['Asset', 'Balance'])

empty = True

if btc_balance:

table.add_row(['BTC', btc_balance]) # BTC

if 'BTC' in totals.keys(): totals['BTC'] += btc_balance

else: totals['BTC'] = btc_balance

empty = False

for balance in balances:

asset = balance['asset']

balance = D(util.devise(db, balance['quantity'], balance['asset'], 'output'))

if balance:

if asset in totals.keys(): totals[asset] += balance

else: totals[asset] = balance

table.add_row([asset, balance])

empty = False

if not empty:

print(address)

print(table.get_string())

print()

for asset in totals.keys():

balance = totals[asset]

total_table.add_row([asset, round(balance, 8)])

print('TOTAL')

print(total_table.get_string())

print()

elif args.action == 'pending':

awaiting_btcs = util.get_order_matches(db, status='pending', is_mine=True)

table = PrettyTable(['Matched Order ID', 'Time Left'])

for order_match in awaiting_btcs:

order_match = format_order_match(db, order_match)

table.add_row(order_match)

print(table)

elif args.action == 'market':

market(args.give_asset, args.get_asset)

# PARSING

elif args.action == 'reparse':

blocks.reparse(db)

elif args.action == 'rollback':

blocks.reparse(db, block_index=args.block_index)

elif args.action == 'server':

api_server = api.APIServer()

api_server.daemon = True

api_server.start()

# Check that Insight works if enabled.

if config.INSIGHT_ENABLE and not args.force:

try:

bitcoin.get_btc_balance(config.UNSPENDABLE, normalize=False)

except requests.exceptions.ConnectionError:

raise exceptions.InsightError('Could not connect to Insight server.')

blocks.follow(db)

else:

parser.print_help()

# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4