View difference between Paste ID: NnNug0nL and h103Yj3N

 #!/usr/bin/env python
 
 """
 bitpaint.py
 ~~~~~~~~~~~
-Simple command-line utility to use the Bitcoin blockchain to track so-called "colored coins", or "smart contracts/securities".
+Simple command-line utility to use the Bitcoin blockchain to track and manage so-called "colored coins", or "smart contracts/securities".
 
-Create "colored coin", receive colored coin, pay to owners of colored coins.
+
 - Private keys are stored in plaintext in your configuration file
-Features:
+
-- Tracking using bitcoind and blockchain.info
+
-- Generate address for colored coin (so you can store
+
-  coins outside your normal wallet, so that the satoshi
+
-  client doesn't accidentally spend them)
+- Since there is no transaction fee included during asset transfer,
-- Start tracking a "colored coin": "paint" a coin
+  you cannot be sure that the transaction will be confirmed when transferring
-- Generate list of holders of colored coin (btc-address and
+  "assets"
-  amount of coin held)
+
-- Transfer colored coin from one address to another
+
 
-Upcoming features:
+
-- Pay from wallet to colored coin owners
+
-- Forward non-colored payments from asset-addresses to
+
-  wallet-addresses
+
 from jsonrpc import ServiceProxy
 from optparse import OptionParser
-Quick guide - issue "security":
+
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
-1. Create a holding address:
+
-   $ python bitpaint.py --new-address
+
-2. Transfer the coins you want to color to that address from your
+
-   regular wallet.
+
-3. Make a note of the transaction id <txid> and the output number
+
-   that transferred the coins to the holding address <n>.
+
-4. Start tracking from the output of that transaction:
+
-   $ python bitpaint.py --paint <name>:<txid>:<n>
+
 # Here we create a configuration file if one does not exist already.
-After these steps, the address you generated holds the full colored
+
-coin. <name> is any name you would like to give this colored coin.
+
-<name> only exists locally.
+
 rpchost = %s
 rpcport = %s
-Quick guide - transfer ownership
+
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
-1. Ask receiver to download this script and generate a holding
+
-   address, <receiver_address>
+
-2. Transfer the colored coin:
+
-   $ python --transfer-from <addr>:<txid>:<n> --transfer-to <receiver_address1>:<amount1>,<receiver_address2>:<amount2>,...
+
 """
 # If the config file does not exists, ask user for details and write one
-Quick guide - list current owners
+
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
-1. Update the list of owners of an asset <name>:
+
-   $ python --update-ownership <name>
+
-2. Show the list of owners:
+
-   $ python --owners <name>
+
 	user = raw_input("bitcoind rpc username (default: <blank>): ")
 	pwd = raw_input("bitcoind rpc password (default: <blank>): ")
-Quick guide - list "colored coins" I own
+
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
-1. Show the list of colored coins owned by my addresses:
+
-   $ python --my-holdings
+
 # 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')
-- Since there is no transaction fee included, you cannot be sure that
+
-  the transaction will be confirmed
+
 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 = 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)
-	user = raw_input("bitcoind rpc username (default: <blank>: ")
+
-	pwd = raw_input("bitcoind rpc password (default: <blank>: ")
+
 			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)))
-bitcoind_connection_string = "http://%s:%s@%s:%s" % (rpcuser,rpcpwd,rpchost,rpcport)
+
 
 	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 = {}
 	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'})
 		pkeys.append(k[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):
-	tx_raw = sp.getrawtransaction(txid)
+
-	tx = sp.decoderawtransaction(tx_raw)
+
 	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, single_input = False):
 	# 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)
 		if single_input and not len(inputs) == 1:
 			print t,"used with multiple inputs: tracking lost at address",address
 			continue
 		for i in inputs:
 			if i == tx_out:
 				return t
 	return None
 
 def rec(prevout_txid, root_tx):
 	# Recursive function to traverse the "tree of ownership", depth-first,
 	# head-recursion.
 	holder_list = []
 
 	if prevout_txid == root_tx:
 		spent_by = spentby(prevout_txid, single_input = False)
 	else:
 		spent_by = spentby(prevout_txid, single_input = True)
 	if spent_by is None:
 		tx_data = gettx(prevout_txid.split(":")[0])
 		o = tx_data['vout'][int(prevout_txid.split(":")[1])]
 		holder_list.append((o['scriptPubKey']['addresses'][0],o['value'],prevout_txid))
 		return holder_list
 	tx_data = gettx(spent_by)
-def rec(prevout_txid):
+
 	for o in tx_data['vout']:
 		ntxid = spent_by+":"+str(o['n'])
 		hl = rec(ntxid,root_tx)
 		for h in hl:
-	spent_by = spentby(prevout_txid, single_input = True)
+			holder_list.append(h)
 
 	return holder_list
 
 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)
-		hl = rec(ntxid)
+	return rec(root_tx_out,root_tx_out)
-		if hl is None:
+
-			holder_list.append((o['scriptPubKey']['addresses'][0],o['value'],ntxid))
+def get_unspent(addr):
 	# Get the unspent transactions for an address
-			for h in hl:
+	# * Following section is disabled because blockchain.info has a bug that
-				holder_list.append(h)
+	#   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 = []
-	return rec(root_tx_out)
+	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")
-	reserved_sections = ['bitcoind', 'HoldingAddresses']
+
 	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]
-				print h, amounts[holders.index(h)],txids[holders.index(h)]
+
 	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
-	tx_input = (txid, int(n), address)
+
 	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", "")
-	######
+
-	# Upcoming:
+
-	# - GUI
+
-	# - Paint coins
+
-	# - Create holding address
+
-	# - Transfer asset
+
-	# - Forward dividends to wallet
+
-	# - Proportional payments to asset holders
+
-	# - Add options for losing track: cutoff, remove, proportional follow.
+
-	######
+
 		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("+")
-	# Not implemented yet - function to safely transfer other unrelated funds (e.g. dividends, coupons, etc.) AWAY from addresses
+
-	# holding some asset:
+
-	#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")
+				total_dividends = 0.0
-	#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")
+				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 start_tracking_coins(name,txid+":"+n)
+
 
 def transfer_asset(sender, receivers):
 	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 opts.transfer_from:
+
-		if opts.transfer_to:
+
 def pay_to_shareholders(name, wallet_acct, total_payment_amount):
 	holders = config.get(name, "holders").split("+")
-			print "Missing address to transfer to"
+
-	if opts.transfer_to:
+
-		if opts.transfer_from:
+	for a in amounts:
 		total += float(a)
 	payouts = {}
-			print "Missing address/input-txid to transfer from"
+	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('-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.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:
 			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"