#!/usr/bin/env python
"""
bitpaint.py
~~~~~~~~~~~
Simple command-line utility to use the Bitcoin blockchain to track and manage so-called "colored coins", or "smart contracts/securities".
Caution:
- Private keys are stored in plaintext in your configuration file
- Colored coin tracking is implemented following the "output
ordering" method, but with very few test cases available,
it is currently difficult to say whether or not the approach is
compatible with approaches implemented elsewhere.
- Remember to include a transaction fee when transferring assets,
so that the transaction will confirm.
(https://bitcointalk.org/index.php?topic=117630.0;all)
Donations welcome: 1GsnaaAWYMb7yPwBQ19bSLLMTtsfSyjqg3
"""
# Import libraries
import jsonrpc
from optparse import OptionParser
import urllib2, ConfigParser, ctypes, ctypes.util, hashlib, simplejson as json, os, sys, binascii, collections
jsonrpc.dumps = json.dumps
### Start: Generic helpers
def JSONtoAmount(value):
return long(round(value * 1e8))
def AmountToJSON(amount):
return float(amount / 1e8)
### End: Generic helpers
### Start: Create/Read Config
# Here we create a configuration file if one does not exist already.
# User is asked for details about his bitcoind so the script can connect.
config_file = "bitpaint.conf"
basic_bitpaint_conf = """[bitcoind]
rpchost = %s
rpcport = %s
rpcuser = %s
rpcpwd = %s
[HoldingAddresses]
addresses =
private_keys =
"""
# If the config file does not exists, ask user for details and write one
if not os.path.exists(config_file):
print "Configuration file bitpaint.conf not found. Creating one..."
host = raw_input("bitcoind rpc host (default: 127.0.0.1): ")
if len(host) == 0: host = "127.0.0.1"
port = raw_input("bitcoind rpc port (default: 8332): ")
if len(port) == 0: port = "8332"
user = raw_input("bitcoind rpc username (default: <blank>): ")
pwd = raw_input("bitcoind rpc password (default: <blank>): ")
f = open(config_file, 'w')
f.write(basic_bitpaint_conf % (host,port,user,pwd))
f.close()
# Parse the config file
reserved_sections = ['bitcoind', 'HoldingAddresses']
config = ConfigParser.ConfigParser()
config.read(config_file)
rpchost = config.get('bitcoind', 'rpchost')
rpcport = config.get('bitcoind', 'rpcport')
rpcuser = config.get('bitcoind', 'rpcuser')
rpcpwd = config.get('bitcoind', 'rpcpwd')
# Connect to bitcoind
if len(rpcuser) == 0 and len(rpcpwd) == 0:
bitcoind_connection_string = "http://s:%s" % (rpchost,rpcport)
else:
bitcoind_connection_string = "http://%s:%s@%s:%s" % (rpcuser,rpcpwd,rpchost,rpcport)
sp = jsonrpc.ServiceProxy(bitcoind_connection_string)
### End: Create/Read Config
### Start: Address Generation code
# The following code was yoinked from addrgen.py
# Thanks to: Joric/bitcoin-dev, june 2012, public domain
ssl = ctypes.cdll.LoadLibrary (ctypes.util.find_library ('ssl') or 'libeay32')
def check_result (val, func, args):
if val == 0: raise ValueError
else: return ctypes.c_void_p (val)
ssl.EC_KEY_new_by_curve_name.restype = ctypes.c_void_p
ssl.EC_KEY_new_by_curve_name.errcheck = check_result
class KEY:
def __init__(self):
NID_secp256k1 = 714
self.k = ssl.EC_KEY_new_by_curve_name(NID_secp256k1)
self.compressed = False
self.POINT_CONVERSION_COMPRESSED = 2
self.POINT_CONVERSION_UNCOMPRESSED = 4
def __del__(self):
if ssl:
ssl.EC_KEY_free(self.k)
self.k = None
def generate(self, secret=None):
if secret:
self.prikey = secret
priv_key = ssl.BN_bin2bn(secret, 32, ssl.BN_new())
group = ssl.EC_KEY_get0_group(self.k)
pub_key = ssl.EC_POINT_new(group)
ctx = ssl.BN_CTX_new()
ssl.EC_POINT_mul(group, pub_key, priv_key, None, None, ctx)
ssl.EC_KEY_set_private_key(self.k, priv_key)
ssl.EC_KEY_set_public_key(self.k, pub_key)
ssl.EC_POINT_free(pub_key)
ssl.BN_CTX_free(ctx)
return self.k
else:
return ssl.EC_KEY_generate_key(self.k)
def get_pubkey(self):
size = ssl.i2o_ECPublicKey(self.k, 0)
mb = ctypes.create_string_buffer(size)
ssl.i2o_ECPublicKey(self.k, ctypes.byref(ctypes.pointer(mb)))
return mb.raw
def get_secret(self):
bn = ssl.EC_KEY_get0_private_key(self.k);
bytes = (ssl.BN_num_bits(bn) + 7) / 8
mb = ctypes.create_string_buffer(bytes)
n = ssl.BN_bn2bin(bn, mb);
return mb.raw.rjust(32, chr(0))
def set_compressed(self, compressed):
self.compressed = compressed
if compressed:
form = self.POINT_CONVERSION_COMPRESSED
else:
form = self.POINT_CONVERSION_UNCOMPRESSED
ssl.EC_KEY_set_conv_form(self.k, form)
def dhash(s):
return hashlib.sha256(hashlib.sha256(s).digest()).digest()
def rhash(s):
h1 = hashlib.new('ripemd160')
h1.update(hashlib.sha256(s).digest())
return h1.digest()
b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def base58_encode(n):
l = []
while n > 0:
n, r = divmod(n, 58)
l.insert(0,(b58_digits[r]))
return ''.join(l)
def base58_decode(s):
n = 0
for ch in s:
n *= 58
digit = b58_digits.index(ch)
n += digit
return n
def base58_encode_padded(s):
res = base58_encode(int('0x' + s.encode('hex'), 16))
pad = 0
for c in s:
if c == chr(0):
pad += 1
else:
break
return b58_digits[0] * pad + res
def base58_decode_padded(s):
pad = 0
for c in s:
if c == b58_digits[0]:
pad += 1
else:
break
h = '%x' % base58_decode(s)
if len(h) % 2:
h = '0' + h
res = h.decode('hex')
return chr(0) * pad + res
def base58_check_encode(s, version=0):
vs = chr(version) + s
check = dhash(vs)[:4]
return base58_encode_padded(vs + check)
def base58_check_decode(s, version=0):
k = base58_decode_padded(s)
v0, data, check0 = k[0], k[1:-4], k[-4:]
check1 = dhash(v0 + data)[:4]
if check0 != check1:
raise BaseException('checksum error')
if version != ord(v0):
raise BaseException('version mismatch')
return data
def gen_eckey(passphrase=None, secret=None, pkey=None, compressed=False, rounds=1):
k = KEY()
if passphrase:
secret = passphrase.encode('utf8')
for i in xrange(rounds):
secret = hashlib.sha256(secret).digest()
if pkey:
secret = base58_check_decode(pkey, 128)
compressed = len(secret) == 33
secret = secret[0:32]
k.generate(secret)
k.set_compressed(compressed)
return k
def get_addr(k):
pubkey = k.get_pubkey()
secret = k.get_secret()
hash160 = rhash(pubkey)
addr = base58_check_encode(hash160)
payload = secret
if k.compressed:
payload = secret + chr(0)
pkey = base58_check_encode(payload, 128)
return addr, pkey
### End: Address Generation code
### Start: Transaction code
def bc_address_to_hash_160(addr):
bytes = b58decode(addr, 25)
return bytes[1:21]
__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
__b58base = len(__b58chars)
def b58decode(v, length):
""" decode v into a string of len bytes
"""
long_value = 0L
for (i, c) in enumerate(v[::-1]):
long_value += __b58chars.find(c) * (__b58base**i)
result = ''
while long_value >= 256:
div, mod = divmod(long_value, 256)
result = chr(mod) + result
long_value = div
result = chr(long_value) + result
nPad = 0
for c in v:
if c == __b58chars[0]: nPad += 1
else: break
result = chr(0)*nPad + result
if length is not None and len(result) != length:
return None
return result
def makek():
# Create a dictionary with address as key and private-key
# as value
a = config.get('HoldingAddresses', 'addresses').split("+")
p = config.get('HoldingAddresses', 'private_keys').split("+")
k = {}
for a in zip(a,p):
k[a[0]] = a[1]
return k
def maketx(inputs, outputs, send=False):
# Create a transaction, sign it - possibly send it - but
# in either case return the raw hex
# inputs: [('a7813e20045b2f2caf612c589adc7e985029167106a300b6a7157084c26967f5', 1, '1PPgZP53BrcG7hyXdWT9fugewmxL1H8LS3'),...]
# outputs: [('1KRavVCsvaLi7ZzktHSCE3hPUvhPDhQKhz', 8000000),...]
ip = []
for txid,vout,_ in inputs:
ip.append({"txid": txid, "vout": vout})
op = collections.OrderedDict()
for addr,amnt in outputs:
op[addr] = AmountToJSON(amnt)
tx = sp.createrawtransaction(ip,op)
k = makek()
ip = []
pkeys = []
for txid,vout,addr in inputs:
ip.append({"txid": txid, "vout": vout, "scriptPubKey": '76a914'+bc_address_to_hash_160(addr).encode('hex')+'88ac'})
if addr in k:
pkeys.append(k[addr])
else:
pkeys.append(sp.dumpprivkey(addr))
final_t = sp.signrawtransaction(tx,ip,pkeys)
if send:
sp.sendrawtransaction(tx)
else:
print final_t['hex']
return final_t['hex']
### End: Transaction code
### Start: Blockchain Inspection/Traversion code
def translate_bctx_to_bitcoindtx(tx_bc):
tx = {}
tx['locktime'] = 0
tx['txid'] = tx_bc['hash']
tx['version'] = tx_bc['ver']
tx['vin'] = []
tx['vout'] = []
for i in tx_bc['inputs']:
v = {}
v['scriptSig'] = {'asm': '', 'hex': ''}
v['sequence'] = 4294967295
v['txid'] = json.loads(urllib2.urlopen("http://blockchain.info/rawtx/%s" % (i['prev_out']['tx_index'],)).read())['hash']
v['vout'] = i['prev_out']['n']
tx['vin'].append(v)
for i in range(len(tx_bc['out'])):
o = tx_bc['out'][i]
v = {}
v['n'] = i
v['scriptPubKey'] = {}
v['scriptPubKey']['addresses'] = [o['addr']]
v['scriptPubKey']['asm'] = []
v['scriptPubKey']['hex'] = []
v['scriptPubKey']['reqSigs'] = 1,
v['scriptPubKey']['type'] = 'pubkeyhash'
v['value'] = float(o['value'])/1e8
tx['vout'].append(v)
return tx
def gettx(txid):
# Get the information of a single transaction, using
# the bitcoind API
try:
tx_raw = sp.getrawtransaction(txid)
tx = sp.decoderawtransaction(tx_raw)
except:
print "Error getting transaction "+txid+" details from bitcoind, trying blockchain.info"
print "http://blockchain.info/rawtx/%s" % (txid,)
tx_bc = json.loads(urllib2.urlopen("http://blockchain.info/rawtx/%s" % (txid,)).read())
tx = translate_bctx_to_bitcoindtx(tx_bc)
return tx
def getaddresstxs(address):
# Get all transactions associated with an address.
# Uses blockchain.info to get this, bitcoind API
# apparently has no equivalent function.
address_info = json.loads(urllib2.urlopen("http://blockchain.info/address/%s?format=json"%(address,) ).read())
tx_list = []
for tx in address_info['txs']:
tx_list.append(tx['hash'])
return tx_list
def getholderschange(txid):
# Get a list of the new holders and old holders represented by a
# single transaction, given as the tx-id.
tid = txid.split(":")
tx = gettx(tid[0])
new_holders = []
old_holders = []
for i in tx['vin']:
old_holders.append(i['txid']+":"+str(i['vout']))
for o in tx['vout']:
new_holders.append((o['scriptPubKey']['addresses'][0], o['value']))
return new_holders, old_holders
def spentby(tx_out):
# Return the id of the transaction which spent the given txid/#
# if single_input is true, it only returns if the tx_out was used as a single
# input to the transaction.
# This is because it is not possible to follow a colored coin across a transaction
# with multiple inputs
tid = tx_out.split(":")
tx = gettx(tid[0])
address = tx['vout'][int(tid[1])]['scriptPubKey']['addresses'][0]
tx_list = getaddresstxs(address)
for t in tx_list:
outputs,inputs = getholderschange(t)
for i in inputs:
if i == tx_out:
return t
return None
def match_outputs_to_inputs(input_values, output_values):
output_belongs_to_input = [-1]*len(output_values)
current_color_number = -1
current_color_total = 0.0
current_color_max = -1
for i in range(len(output_values)):
output_value = output_values[i]
while current_color_total+output_value > current_color_max:
current_color_number += 1
current_color_total = 0.0
if current_color_number >= len(input_values): return output_belongs_to_input
current_color_max = input_values[current_color_number]
output_belongs_to_input[i] = current_color_number
current_color_total += output_value
return output_belongs_to_input
def get_relevant_outputs(tx_data,prevout_txid):
global lost_track
relevant_outputs = []
input_values = []
output_values = []
input_colors = [-1]*len(tx_data['vin'])
for pon in range(len(tx_data['vin'])):
po = tx_data['vin'][pon]
p_tid = po['txid']+":"+str(po['vout'])
if p_tid == prevout_txid:
input_colors[pon] = 0
po_data = gettx(po['txid'])
input_values.append(po_data['vout'][po['vout']]['value'])
for pon in range(len(tx_data['vin'])):
p_tid = po['txid']+":"+str(po['vout'])
if p_tid in lost_track:
po_data = gettx(po['txid'])
input_values[input_colors.index(0)] += po_data['vout'][po['vout']]['value']
input_values[pon] = 0
lost_track.remove(p_tid)
for o in tx_data['vout']:
output_values.append(o['value'])
output_colors = match_outputs_to_inputs(input_values, output_values)
for o in range(len(output_colors)):
if output_colors[o] == 0:
relevant_outputs.append(tx_data['txid']+":"+str(o))
return relevant_outputs
def rec(prevout_txid, root_tx):
holder_list = []
spent_by = spentby(prevout_txid)
txid,n = prevout_txid.split(":")
if spent_by is None:
tx_data = gettx(txid)
o = tx_data['vout'][int(n)]
holder_list.append((o['scriptPubKey']['addresses'][0],o['value'],prevout_txid))
return holder_list
tx_data = gettx(spent_by)
relevant_outputs = get_relevant_outputs(tx_data,prevout_txid)
if len(relevant_outputs) == 0:
lost_track.append(spent_by)
for ro in relevant_outputs:
hl = rec(ro,root_tx)
for h in hl:
holder_list.append(h)
return holder_list
lost_track = []
def get_current_holders(root_tx_out):
# Get the current holders of the "colored coin" with
# the given root (a string with txid+":"+n_output)
global lost_track
lost_track = []
return rec(root_tx_out,root_tx_out)
def get_unspent(addr):
# Get the unspent transactions for an address
# * Following section is disabled because blockchain.info has a bug that
# returns the wrong transaction IDs.
#d = json.loads(urllib2.urlopen('http://blockchain.info/unspent?address=%s' % addr).read())
#return d
# * Start of blockchain.info bug workaround:
txs = getaddresstxs(addr)
received = []
sent = []
for txid in txs:
tx = gettx(txid)
for i in tx['vin']:
prev_out = gettx(i['txid'])
for po in prev_out['vout']:
n = po['n']
po = po['scriptPubKey']
if po['type'] == 'pubkeyhash':
if po['addresses'][0] == addr:
sent.append(i['txid']+":"+str(n))
for o in tx['vout']:
n = o['n']
o = o['scriptPubKey']
if o['type'] == 'pubkeyhash':
if o['addresses'][0] == addr:
received.append(txid+":"+str(n))
unspent = []
for r in received:
if r not in sent:
d = {}
txid,n = r.split(":")
d['tx_hash'] = txid
d['tx_output_n'] = int(n)
d['value'] = int(1e8*gettx(txid)['vout'][int(n)]['value'])
unspent.append(d)
return unspent
# * End of blockchain.info bug workaround
def get_non_asset_funds(addr):
unspent = get_unspent(addr)
asset_txids = []
for s in config.sections():
if s in reserved_sections: continue
for txid in config.get(s, 'txid').split("+"):
asset_txids.append(txid)
naf = []
for u in unspent:
txid = u['tx_hash']+":"+str(u['tx_output_n'])
if not txid in asset_txids:
naf.append(u)
return naf
### End: Blockchain Inspection/Traversion code
### Start: "User-facing" methods
def generate_holding_address():
# Generate an address, add it to the config file
addr, pkey = get_addr(gen_eckey())
addresses = config.get('HoldingAddresses', 'addresses')
private_keys = config.get('HoldingAddresses', 'private_keys')
if len(addresses) > 5:
config.set('HoldingAddresses', 'addresses', '+'.join([addresses,addr]))
config.set('HoldingAddresses', 'private_keys', '+'.join([private_keys,pkey]))
else:
config.set('HoldingAddresses', 'addresses', addr)
config.set('HoldingAddresses', 'private_keys', pkey)
config.write(open(config_file,'w'))
return "Address added: "+addr
def update_tracked_coins(name):
# Update the list of owners of a tracked coin
# and write to the config file
root_tx = config.get(name, "root_tx")
current_holders = get_current_holders(root_tx)
holding_addresses = ""
holding_amounts = ""
holding_txids = ""
total = 0.0
for h in current_holders:
holding_addresses += "+" + h[0]
holding_amounts += "+" + str(h[1])
holding_txids += "+" + h[2]
config.set(name, "holders", holding_addresses[1:])
config.set(name, "amounts", holding_amounts[1:])
config.set(name, "txid", holding_txids[1:])
config.write(open(config_file,'w'))
def start_tracking_coins(name,txid):
# Give a name of a tracked coin, together with a
# root output that will be used to track it.
# Write this to the config file, and update the
# list of owners.
if name in config.sections():
return name+" already exists."
config.add_section(name)
config.set(name, "root_tx", txid)
config.set(name, "holders", "")
config.set(name, "amounts", "")
config.set(name, "txid", "")
config.write(open(config_file,'w'))
update_tracked_coins(name)
def show_holders(name):
holders = config.get(name, "holders").split("+")
amounts = config.get(name, "amounts").split("+")
txids = config.get(name,"txid").split("+")
total = 0.0
print "*** %s ***" % (name,)
for h in zip(holders,amounts,txids):
print h[0],h[1],h[2]
total += float(h[1])
print "** Total %s: %f **" % (name,total)
def show_my_holdings():
sections = config.sections()
my_holding_addresses = config.get('HoldingAddresses', 'addresses').split("+")
for s in sections:
if s in reserved_sections: continue
holders = config.get(s, "holders").split("+")
amounts = config.get(s, "amounts").split("+")
txids = config.get(s, "txid").split("+")
for h in holders:
if h in my_holding_addresses:
total_dividends = 0.0
for naf in get_non_asset_funds(h):
total_dividends += float(naf['value'])/1e8
print s,amounts[holders.index(h)],"( div:",total_dividends,")",h,txids[holders.index(h)]
def show_my_holding_addresses():
my_holding_addresses = config.get('HoldingAddresses', 'addresses').split("+")
for a in my_holding_addresses:
print a
def show_colors():
sections = config.sections()
for s in sections:
if s in reserved_sections: continue
print s,config.get(s, 'root_tx')
def transfer_asset(sender, receivers,fee_size=None):
address,txid,n = sender.split(":")
tx_input = [(txid, int(n), address)]
tx_outputs = []
for l in receivers.split(","):
address,amount = l.split(":")
tx_outputs.append((address,int(float(amount)*1e8)))
if fee_size:
fee_p_out = sp.listunspent()[0]
in_addr = base58_check_encode(binascii.unhexlify(fee_p_out['scriptPubKey'][6:-4]))
change_address = config.get("bitcoind","change_address")
change_amount = fee_p_out['amount']-fee_size
tx_input.append((fee_p_out['txid'],fee_p_out['vout'],in_addr))
tx_outputs.append((change_address, int(1e8*change_amount)))
raw_transaction = maketx(tx_input, tx_outputs)
def pay_to_shareholders(name, wallet_acct, total_payment_amount):
holders = config.get(name, "holders").split("+")
amounts = config.get(name, "amounts").split("+")
total = 0.0
for a in amounts:
total += float(a)
payouts = {}
for h,a in zip(holders,amounts):
d = total_payment_amount*float(a)/total
payouts[h] = d
sp.sendmany(wallet_acct,payouts)
print "Payouts made:"
for k in payouts.keys():
print k,":",payouts[k]
def transfer_others(transfer_other_from,transfer_other_to):
naf = get_non_asset_funds(transfer_other_from)
fee = int(1e8*0.005)
total_value = 0
inputs = []
for u in naf:
total_value += u['value']
i = (u['tx_hash'], u['tx_output_n'], transfer_other_from)
inputs.append(i)
outputs = [(transfer_other_to, total_value-fee)]
maketx(inputs,outputs,send=False)
print "Paid",float(total_value-fee)/1e8,"to",transfer_other_to
if __name__ == '__main__':
# Process command-line options
parser = OptionParser()
parser.add_option('-p', '--paint', help='Paint coins for tracking', dest='paint_txid', action='store')
parser.add_option('-n', '--new-address', help='Create new holding address for colored coins', dest='gen_address', default=False, action='store_true')
parser.add_option('-l', '--list-colors', help='List of names of painted coins being tracked', dest='list_colors', default=False, action='store_true')
parser.add_option('-u', '--update-ownership', help='Update ownership info for painted coins', dest='update_name', action='store')
parser.add_option('-o', '--owners', help='Show owners of painted coins', dest="holders_name", action="store")
parser.add_option('-m', '--my-holdings', help='Show holdings at my addresses', dest="show_holdings", action="store_true")
parser.add_option('-a', '--holding-addresses', help='Show my holding addresses', dest="show_addresses", action="store_true")
parser.add_option('-f', '--transfer-from', help='Asset to transfer to another address. address:txid:n', dest='transfer_from', action="store")
parser.add_option('-t', '--transfer-to', help='Address to transfer asset to. address:amount,...', dest='transfer_to', action="store")
parser.add_option('-d', '--pay-holders', help="Pay from your bitcoind wallet to asset holders: <asset_name>:<wallet_acctname>:<payout_amount>", dest="pay_to_holders", action="store")
parser.add_option('-w', '--fee', help="Pay a transaction fee from your wallet when transferring an asset: <amount>", dest="fee", action="store")
parser.add_option('-x', '--transfer-other-from', help='Transfer bitcoins UNRELATED to the tracked address/coins away from this address', dest="transfer_other_from", action="store")
parser.add_option('-y', '--transfer-other-to', help='Transfer bitcoins UNRELATED to the tracked address/coins to this address', dest="transfer_other_to", action="store")
opts, args = parser.parse_args()
if opts.gen_address:
print generate_holding_address()
if opts.paint_txid:
name,txid,n = opts.paint_txid.split(":")
start_tracking_coins(name,txid+":"+n)
if opts.holders_name:
show_holders(opts.holders_name)
if opts.update_name:
update_tracked_coins(opts.update_name)
if opts.list_colors:
show_colors()
if opts.show_holdings:
show_my_holdings()
if opts.show_addresses:
show_my_holding_addresses()
if opts.pay_to_holders:
asset_name, wallet_acct_name, amount = opts.pay_to_holders.split(":")
pay_to_shareholders(asset_name, wallet_acct_name, float(amount))
if opts.transfer_from or opts.transfer_to:
if opts.transfer_to and opts.transfer_from:
if opts.fee:
transfer_asset(opts.transfer_from, opts.transfer_to,fee_size=float(opts.fee))
else:
transfer_asset(opts.transfer_from, opts.transfer_to)
else:
print "Make sure you give both a source and destination"
if opts.transfer_other_from or opts.transfer_other_to:
if opts.transfer_other_to and opts.transfer_other_from:
transfer_others(opts.transfer_other_from,opts.transfer_other_to)
else:
print "Make sure you give both a source and destination"
