def get_dust_return_pubkey(db, source, provided_pubkeys, encoding):
"""Return the pubkey to which dust from data outputs will be sent.
This pubkey is used in multi-sig data outputs (as the only real pubkey) to
make those the outputs spendable. It is derived from the source address, so
that the dust is spendable by the creator of the transaction.
"""
# Get hex dust return pubkey.
if script.is_multisig(source):
_, self_pubkeys, _ = script.extract_array(
backend.multisig_pubkeyhashes_to_pubkeys(source, provided_pubkeys))
dust_return_pubkey_hex = self_pubkeys[0]
else:
cursor = db.cursor()
sql = '''SELECT pubkey FROM pubkeys WHERE address = ? LIMIT 1'''
pubkeys = list(cursor.execute(sql, (source, )))
if len(pubkeys) == 0:
raise UnknownPubKeyError(
'Public key was neither provided nor published in blockchain.')
else:
dust_return_pubkey_hex = pubkeys[0]['pubkey']
# Convert hex public key into the (binary) dust return pubkey.
try:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey_hex)
except binascii.Error:
raise script.InputError('Invalid public key.')
return dust_return_pubkey
def call(method, args, pubkey_resolver=None):
"""
Unified function to call Wallet and Counterparty API methods
Should be used by applications like `counterparty-gui`
:Example:
import counterpartycli.clientapi
clientapi.initialize(...)
unsigned_hex = clientapi.call('create_send', {...})
signed_hex = clientapi.call('sign_raw_transaction', unsigned_hex)
tx_hash = clientapi.call('send_raw_transaction', signed_hex)
"""
if method in WALLET_METHODS:
func = getattr(wallet, method)
return func(**args)
else:
if method.startswith('create_'):
# Get provided pubkeys from params.
pubkeys = []
for address_name in ['source', 'destination']:
if address_name in args:
address = args[address_name]
if script.is_multisig(address) or address_name != 'destination': # We don’t need the pubkey for a mono‐sig destination.
pubkeys += get_pubkeys(address, pubkey_resolver=pubkey_resolver)
args['pubkey'] = pubkeys
result = util.api(method, args)
if method.startswith('create_'):
messages.check_transaction(method, args, result)
return result
def call(method, args, pubkey_resolver=None):
"""
Unified function to call Wallet and Server API methods
Should be used by applications like `counterparty-gui`
:Example:
import counterpartycli.clientapi
clientapi.initialize(...)
unsigned_hex = clientapi.call('create_send', {...})
signed_hex = clientapi.call('sign_raw_transaction', unsigned_hex)
tx_hash = clientapi.call('send_raw_transaction', signed_hex)
"""
if method in WALLET_METHODS:
func = getattr(wallet, method)
return func(**args)
else:
if method.startswith('create_'):
# Get provided pubkeys from params.
pubkeys = []
for address_name in ['source', 'destination']:
if address_name in args:
address = args[address_name]
if script.is_multisig(address) or address_name != 'destination': # We don’t need the pubkey for a mono‐sig destination.
pubkeys += get_pubkeys(address, pubkey_resolver=pubkey_resolver)
args['pubkey'] = pubkeys
result = util.api(method, args)
if method.startswith('create_'):
messages.check_transaction(method, args, result)
return result
def get_unspent_txouts(source, return_confirmed=False):
"""returns a list of unspent outputs for a specific address
@return: A list of dicts, with each entry in the dict having the following keys:
"""
# Get all coins.
outputs = {}
if script.is_multisig(source):
pubkeyhashes = script.pubkeyhash_array(source)
raw_transactions = searchrawtransactions(pubkeyhashes[1])
else:
pubkeyhashes = [source]
raw_transactions = searchrawtransactions(source)
for tx in raw_transactions:
for vout in tx['vout']:
if is_vout_spendable(vout, source):
txid = tx['txid']
confirmations = tx[
'confirmations'] if 'confirmations' in tx else 0
outkey = '{}{}'.format(txid, vout['n'])
if outkey not in outputs or outputs[outkey][
'confirmations'] < confirmations:
coin = {
'amount': float(vout['value']),
'confirmations': confirmations,
'scriptPubKey': vout['scriptPubKey']['hex'],
'txid': txid,
'vout': vout['n']
}
outputs[outkey] = coin
outputs = outputs.values()
# Prune away spent coins.
unspent = []
confirmed_unspent = []
for output in outputs:
spent = False
confirmed_spent = False
for tx in raw_transactions:
for vin in tx['vin']:
if 'coinbase' in vin:
continue
if (vin['txid'], vin['vout']) == (output['txid'],
output['vout']):
spent = True
if 'confirmations' in tx and tx['confirmations'] > 0:
confirmed_spent = True
if not spent:
unspent.append(output)
if not confirmed_spent and output['confirmations'] > 0:
confirmed_unspent.append(output)
unspent = sorted(unspent, key=lambda x: x['txid'])
confirmed_unspent = sorted(confirmed_unspent, key=lambda x: x['txid'])
if return_confirmed:
return unspent, confirmed_unspent
else:
return unspent
def get_script(address):
if script.is_multisig(address):
return get_multisig_script(address)
else:
try:
return get_monosig_script(address)
except script.VersionByteError as e:
return get_p2sh_script(address)
def get_script(address):
if script.is_multisig(address):
return get_multisig_script(address)
else:
try:
return get_monosig_script(address)
except script.VersionByteError as e:
return get_p2sh_script(address)
def get_pubkeys(address, pubkey_resolver=input_pubkey):
pubkeys = []
if script.is_multisig(address):
_, pubs, _ = script.extract_array(address)
for pub in pubs:
pubkey = get_pubkey_monosig(pub, pubkey_resolver=pubkey_resolver)
if pubkey:
pubkeys.append(pubkey)
else:
pubkey = get_pubkey_monosig(address, pubkey_resolver=pubkey_resolver)
if pubkey:
pubkeys.append(pubkey)
return pubkeys
def get_pubkeys(address, pubkey_resolver=input_pubkey):
pubkeys = []
if script.is_multisig(address):
_, pubs, _ = script.extract_array(address)
for pub in pubs:
pubkey = get_pubkey_monosig(pub, pubkey_resolver=pubkey_resolver)
if pubkey:
pubkeys.append(pubkey)
else:
pubkey = get_pubkey_monosig(address, pubkey_resolver=pubkey_resolver)
if pubkey:
pubkeys.append(pubkey)
return pubkeys
def compose_transaction(args, message_name, param_names):
args = prepare_args(args, message_name)
common_params = common_args(args)
params = extract_args(args, param_names)
params.update(common_params)
# Get provided pubkeys from params.
pubkeys = []
for address_name in ['source', 'destination']:
if address_name in params:
address = params[address_name]
if script.is_multisig(address) or address_name != 'destination': # We don’t need the pubkey for a mono‐sig destination.
pubkeys += get_pubkeys(address)
params['pubkey'] = pubkeys
method = 'create_{}'.format(message_name)
unsigned_tx_hex = util.api(method, params)
# check_transaction(method, params, unsigned_tx_hex)
return unsigned_tx_hex
def compose_transaction(args, message_name, param_names):
args = prepare_args(args, message_name)
common_params = common_args(args)
params = extract_args(args, param_names)
params.update(common_params)
# Get provided pubkeys from params.
pubkeys = []
for address_name in ['source', 'destination']:
if address_name in params:
address = params[address_name]
if script.is_multisig(address) or address_name != 'destination': # We don’t need the pubkey for a mono‐sig destination.
pubkeys += get_pubkeys(address)
params['pubkey'] = pubkeys
method = 'create_{}'.format(message_name)
unsigned_tx_hex = util.api(method, params)
# check_transaction(method, params, unsigned_tx_hex)
return unsigned_tx_hex
def get_dust_return_pubkey(source, provided_pubkeys, encoding):
"""Return the pubkey to which dust from data outputs will be sent.
This pubkey is used in multi-sig data outputs (as the only real pubkey) to
make those the outputs spendable. It is derived from the source address, so
that the dust is spendable by the creator of the transaction.
"""
# Get hex dust return pubkey.
if script.is_multisig(source):
a, self_pubkeys, b = script.extract_array(backend.multisig_pubkeyhashes_to_pubkeys(source, provided_pubkeys))
dust_return_pubkey_hex = self_pubkeys[0]
else:
dust_return_pubkey_hex = backend.pubkeyhash_to_pubkey(source, provided_pubkeys)
# Convert hex public key into the (binary) dust return pubkey.
try:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey_hex)
except binascii.Error:
raise script.InputError('Invalid private key.')
return dust_return_pubkey
def get_dust_return_pubkey(source, provided_pubkeys, encoding):
"""Return the pubkey to which dust from data outputs will be sent.
This pubkey is used in multi-sig data outputs (as the only real pubkey) to
make those the outputs spendable. It is derived from the source address, so
that the dust is spendable by the creator of the transaction.
"""
# Get hex dust return pubkey.
if script.is_multisig(source):
a, self_pubkeys, b = script.extract_array(
backend.multisig_pubkeyhashes_to_pubkeys(source, provided_pubkeys))
dust_return_pubkey_hex = self_pubkeys[0]
else:
dust_return_pubkey_hex = backend.pubkeyhash_to_pubkey(
source, provided_pubkeys)
# Convert hex public key into the (binary) dust return pubkey.
try:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey_hex)
except binascii.Error:
raise script.InputError('Invalid private key.')
return dust_return_pubkey
def get_dust_return_pubkey(source, provided_pubkeys, encoding):
# Get `dust_return_pubkey`, if necessary.
if encoding in ('multisig', 'pubkeyhash'):
# Get hex dust return pubkey.
if script.is_multisig(source):
a, self_pubkeys, b = script.extract_array(
backend.multisig_pubkeyhashes_to_pubkeys(
source, provided_pubkeys))
dust_return_pubkey_hex = self_pubkeys[0]
else:
dust_return_pubkey_hex = backend.pubkeyhash_to_pubkey(
source, provided_pubkeys)
# Convert hex public key into the (binary) dust return pubkey.
try:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey_hex)
except binascii.Error:
raise script.InputError('Invalid private key.')
else:
dust_return_pubkey = None
return dust_return_pubkey
def main():
if os.name == 'nt':
from counterpartylib.lib import util_windows
#patch up cmd.exe's "challenged" (i.e. broken/non-existent) UTF-8 logging
util_windows.fix_win32_unicode()
# Post installation tasks
generate_config_files()
# Parse command-line arguments.
parser = argparse.ArgumentParser(
prog=APP_NAME,
description='Counterparty CLI for counterparty-server',
add_help=False)
parser.add_argument('-h',
'--help',
dest='help',
action='store_true',
help='show this help message and exit')
parser.add_argument('-V',
'--version',
action='version',
version="{} v{}; {} v{}".format(
APP_NAME, APP_VERSION, 'counterparty-lib',
config.VERSION_STRING))
parser.add_argument('--config-file',
help='the location of the configuration file')
parser = add_config_arguments(parser, CONFIG_ARGS, 'client.conf')
subparsers = parser.add_subparsers(dest='action',
help='the action to be taken')
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_send.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
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.DEFAULT_FEE_FRACTION_REQUIRED,
help=
'the miners’ fee required for an order to match this one, as a fraction of the {} to be bought'
.format(config.BTC))
parser_order_fees = parser_order.add_mutually_exclusive_group()
parser_order_fees.add_argument(
'--fee-fraction-provided',
default=config.DEFAULT_FEE_FRACTION_PROVIDED,
help='the miners’ fee provided, as a fraction of the {} to be sold'.
format(config.BTC))
parser_order_fees.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_btcpay = subparsers.add_parser(
'{}pay'.format(config.BTC).lower(),
help=
'create and broadcast a *{}pay* message, to settle an Order Match for which you owe {}'
.format(config.BTC, config.BTC))
parser_btcpay.add_argument('--source',
required=True,
help='the source address')
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_btcpay.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
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(
'--description',
type=str,
required=True,
help=
'a description of the asset (set to ‘LOCK’ to lock against further issuances with non‐zero quantitys)'
)
parser_issuance.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
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_broadcast.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
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(BET_TYPE_NAME.values()),
required=True,
help='choices: {}'.format(
list(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_bet.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
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_dividend.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_burn = subparsers.add_parser(
'burn',
help='destroy {} 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 {} to be burned'.format(
config.BTC))
parser_burn.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_cancel = subparsers.add_parser(
'cancel', help='cancel an open order or bet you created')
parser_cancel.add_argument('--source',
required=True,
help='the source address')
parser_cancel.add_argument('--offer-hash',
required=True,
help='the transaction hash of the order or bet')
parser_cancel.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_rps = subparsers.add_parser(
'rps', help='open a rock-paper-scissors like game')
parser_rps.add_argument('--source',
required=True,
help='the source address')
parser_rps.add_argument('--wager',
required=True,
help='the quantity of XCP to wager')
parser_rps.add_argument('--move',
type=int,
required=True,
help='the selected move')
parser_rps.add_argument(
'--possible-moves',
type=int,
required=True,
help='the number of possible moves (odd number greater or equal than 3)'
)
parser_rps.add_argument(
'--expiration',
type=int,
required=True,
help='the number of blocks for which the bet should be valid')
parser_rps.add_argument('--fee',
help='the exact BTC fee to be paid to miners')
parser_rpsresolve = subparsers.add_parser(
'rpsresolve', help='resolve a rock-paper-scissors like game')
parser_rpsresolve.add_argument('--source',
required=True,
help='the source address')
parser_rpsresolve.add_argument(
'--random',
type=str,
required=True,
help='the random number used in the corresponding rps transaction')
parser_rpsresolve.add_argument(
'--move',
type=int,
required=True,
help='the selected move in the corresponding rps transaction')
parser_rpsresolve.add_argument(
'--rps-match-id',
required=True,
help=
'the concatenation of the hashes of the two transactions which compose the rps match'
)
parser_rpsresolve.add_argument(
'--fee', help='the exact BTC fee to be paid to miners')
parser_publish = subparsers.add_parser(
'publish', help='publish contract code in the blockchain')
parser_publish.add_argument('--source',
required=True,
help='the source address')
parser_publish.add_argument('--gasprice',
required=True,
type=int,
help='the price of gas')
parser_publish.add_argument(
'--startgas',
required=True,
type=int,
help=
'the maximum quantity of {} to be used to pay for the execution (satoshis)'
.format(config.XCP))
parser_publish.add_argument(
'--endowment',
required=True,
type=int,
help='quantity of {} to be transfered to the contract (satoshis)'.
format(config.XCP))
parser_publish.add_argument(
'--code-hex',
required=True,
type=str,
help='the hex‐encoded contract (returned by `serpent compile`)')
parser_publish.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_execute = subparsers.add_parser(
'execute', help='execute contract code in the blockchain')
parser_execute.add_argument('--source',
required=True,
help='the source address')
parser_execute.add_argument(
'--contract-id',
required=True,
help='the contract ID of the contract to be executed')
parser_execute.add_argument('--gasprice',
required=True,
type=int,
help='the price of gas')
parser_execute.add_argument(
'--startgas',
required=True,
type=int,
help=
'the maximum quantity of {} to be used to pay for the execution (satoshis)'
.format(config.XCP))
parser_execute.add_argument(
'--value',
required=True,
type=int,
help='quantity of {} to be transfered to the contract (satoshis)'.
format(config.XCP))
parser_execute.add_argument(
'--payload-hex',
required=True,
type=str,
help=
'data to be provided to the contract (returned by `serpent encode_datalist`)'
)
parser_execute.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_destroy = subparsers.add_parser(
'destroy', help='destroy a quantity of a Counterparty asset')
parser_destroy.add_argument('--source',
required=True,
help='the source address')
parser_destroy.add_argument(
'--asset',
required=True,
help='the ASSET of which you would like to destroy QUANTITY')
parser_destroy.add_argument('--quantity',
required=True,
help='the quantity of ASSET to destroy')
parser_destroy.add_argument('--tag', default='', help='tag')
parser_destroy.add_argument(
'--fee',
help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_address = subparsers.add_parser(
'balances',
help='display the balances of a {} address'.format(config.XCP_NAME))
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 {} asset'.format(
config.XCP_NAME))
parser_asset.add_argument('asset', help='the asset you are interested in')
parser_wallet = subparsers.add_parser(
'wallet',
help=
'list the addresses in your backend wallet along with their balances in all {} assets'
.format(config.XCP_NAME))
parser_pending = subparsers.add_parser(
'pending',
help='list pending order matches awaiting {}payment from you'.format(
config.BTC))
parser_getrows = subparsers.add_parser(
'getrows', help='get rows from a Counterparty table')
parser_getrows.add_argument('--table', required=True, help='table name')
parser_getrows.add_argument('--filter',
nargs=3,
action='append',
help='filters to get specific rows')
parser_getrows.add_argument('--filter-op',
choices=['AND', 'OR'],
help='operator uses to combine filters',
default='AND')
parser_getrows.add_argument('--order-by',
help='field used to order results')
parser_getrows.add_argument('--order-dir',
choices=['ASC', 'DESC'],
help='direction used to order results')
parser_getrows.add_argument(
'--start-block',
help='return only rows with block_index greater than start-block')
parser_getrows.add_argument(
'--end-block',
help='return only rows with block_index lower than end-block')
parser_getrows.add_argument(
'--status', help='return only rows with the specified status')
parser_getrows.add_argument('--limit',
help='number of rows to return',
default=100)
parser_getrows.add_argument('--offset',
help='number of rows to skip',
default=0)
parser_getrunninginfo = subparsers.add_parser(
'getinfo', help='get the current state of the server')
args = parser.parse_args()
# Logging
log.set_up(logger, verbose=args.verbose)
logger.propagate = False
logger.info('Running v{} of {}.'.format(APP_VERSION, APP_NAME))
# Help message
if args.help:
parser.print_help()
sys.exit()
# Configuration
clientapi.initialize(
testnet=args.testnet,
testcoin=args.testcoin,
counterparty_rpc_connect=args.counterparty_rpc_connect,
counterparty_rpc_port=args.counterparty_rpc_port,
counterparty_rpc_user=args.counterparty_rpc_user,
counterparty_rpc_password=args.counterparty_rpc_password,
counterparty_rpc_ssl=args.counterparty_rpc_ssl,
counterparty_rpc_ssl_verify=args.counterparty_rpc_ssl_verify,
wallet_name=args.wallet_name,
wallet_connect=args.wallet_connect,
wallet_port=args.wallet_port,
wallet_user=args.wallet_user,
wallet_password=args.wallet_password,
wallet_ssl=args.wallet_ssl,
wallet_ssl_verify=args.wallet_ssl_verify,
requests_timeout=args.requests_timeout)
# MESSAGE CREATION
if args.action in list(messages.MESSAGE_PARAMS.keys()):
unsigned_hex = messages.compose(args.action, args)
logger.info('Transaction (unsigned): {}'.format(unsigned_hex))
if not args.unsigned:
if script.is_multisig(args.source):
logger.info(
'Multi‐signature transactions are signed and broadcasted manually.'
)
elif input('Sign and broadcast? (y/N) ') == 'y':
if wallet.is_mine(args.source):
if wallet.is_locked():
passphrase = getpass.getpass(
'Enter your wallet passhrase: ')
logger.info('Unlocking wallet for 60 (more) seconds.')
wallet.unlock(passphrase)
signed_tx_hex = wallet.sign_raw_transaction(unsigned_hex)
else:
private_key_wif = input(
'Source address not in wallet. Please enter the private key in WIF format for {}:'
.format(args.source))
if not private_key_wif:
raise TransactionError('invalid private key')
signed_tx_hex = wallet.sign_raw_transaction(
unsigned_hex, private_key_wif=private_key_wif)
logger.info('Transaction (signed): {}'.format(signed_tx_hex))
tx_hash = wallet.send_raw_transaction(signed_tx_hex)
logger.info(
'Hash of transaction (broadcasted): {}'.format(tx_hash))
# VIEWING
elif args.action in [
'balances', 'asset', 'wallet', 'pending', 'getinfo', 'getrows'
]:
view = console.get_view(args.action, args)
print_method = getattr(console, 'print_{}'.format(args.action), None)
if args.json_output or print_method is None:
util.json_print(view)
else:
print_method(view)
else:
parser.print_help()
def get_unspent_txouts(source, unconfirmed=False, multisig_inputs=False, unspent_tx_hash=None):
"""returns a list of unspent outputs for a specific address
@return: A list of dicts, with each entry in the dict having the following keys:
"""
if not MEMPOOL_CACHE_INITIALIZED:
raise MempoolError('Mempool is not yet ready; please try again in a few minutes.')
# Get all outputs.
logger.debug('Getting outputs.')
if unspent_tx_hash:
raw_transactions = [getrawtransaction(unspent_tx_hash, verbose=True)]
else:
if script.is_multisig(source):
pubkeyhashes = script.pubkeyhash_array(source)
raw_transactions = searchrawtransactions(pubkeyhashes[1], unconfirmed=True) # unconfirmed=True to prune unconfirmed spent outputs
else:
pubkeyhashes = [source]
raw_transactions = searchrawtransactions(source, unconfirmed=True)
# Change format.
# TODO: Slow.
logger.debug('Formatting outputs.')
outputs = {}
for tx in raw_transactions:
for vout in tx['vout']:
txid = tx['txid']
confirmations = tx['confirmations'] if 'confirmations' in tx else 0
outkey = '{}{}'.format(txid, vout['n']) # edge case: avoid duplicate output
if outkey not in outputs or outputs[outkey]['confirmations'] < confirmations:
coin = {
'amount': float(vout['value']),
'confirmations': confirmations,
'scriptPubKey': vout['scriptPubKey']['hex'],
'txid': txid,
'vout': vout['n']
}
outputs[outkey] = coin
outputs = sorted(outputs.values(), key=lambda x: x['confirmations'])
# Prune unspendable.
logger.debug('Pruning unspendable outputs.')
# TODO: Slow.
outputs = [output for output in outputs if is_scriptpubkey_spendable(output['scriptPubKey'], source)]
# Prune spent outputs.
logger.debug('Pruning spent outputs.')
vins = {(vin['txid'], vin['vout']) for tx in raw_transactions for vin in tx['vin'] if 'coinbase' not in vin}
unspent = []
for output in outputs:
if (output['txid'], output['vout']) not in vins:
unspent.append(output)
unspent = sorted(unspent, key=lambda x: x['txid'])
# Remove unconfirmed txouts, if desired.
if not unconfirmed:
unspent = [output for output in unspent if output['confirmations'] > 0]
else:
# Hackish: Allow only inputs which are either already confirmed or were seen only recently. (Skip outputs from slow‐to‐confirm transanctions.)
try:
unspent = [output for output in unspent if output['confirmations'] > 0 or (time.time() - output['ts']) < 6 * 3600] # Cutoff: six hours
except (KeyError, TypeError):
pass
return unspent
def main():
if os.name == 'nt':
from counterpartylib.lib import util_windows
#patch up cmd.exe's "challenged" (i.e. broken/non-existent) UTF-8 logging
util_windows.fix_win32_unicode()
# Post installation tasks
generate_config_files()
# Parse command-line arguments.
parser = argparse.ArgumentParser(prog=APP_NAME, description='Counterparty CLI for counterparty-server', add_help=False)
parser.add_argument('-h', '--help', dest='help', action='store_true', help='show this help message and exit')
parser.add_argument('-V', '--version', action='version', version="{} v{}; {} v{}".format(APP_NAME, APP_VERSION, 'counterparty-lib', config.VERSION_STRING))
parser.add_argument('--config-file', help='the location of the configuration file')
parser = add_config_arguments(parser, CONFIG_ARGS, 'client.conf')
subparsers = parser.add_subparsers(dest='action', help='the action to be taken')
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_send.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
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.DEFAULT_FEE_FRACTION_REQUIRED, help='the miners’ fee required for an order to match this one, as a fraction of the {} to be bought'.format(config.BTC))
parser_order_fees = parser_order.add_mutually_exclusive_group()
parser_order_fees.add_argument('--fee-fraction-provided', default=config.DEFAULT_FEE_FRACTION_PROVIDED, help='the miners’ fee provided, as a fraction of the {} to be sold'.format(config.BTC))
parser_order_fees.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_btcpay = subparsers.add_parser('{}pay'.format(config.BTC).lower(), help='create and broadcast a *{}pay* message, to settle an Order Match for which you owe {}'.format(config.BTC, config.BTC))
parser_btcpay.add_argument('--source', required=True, help='the source address')
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_btcpay.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
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('--description', type=str, required=True, help='a description of the asset (set to ‘LOCK’ to lock against further issuances with non‐zero quantitys)')
parser_issuance.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
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_broadcast.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
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(BET_TYPE_NAME.values()), required=True, help='choices: {}'.format(list(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_bet.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
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_dividend.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_burn = subparsers.add_parser('burn', help='destroy {} 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 {} to be burned'.format(config.BTC))
parser_burn.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_cancel = subparsers.add_parser('cancel', help='cancel an open order or bet you created')
parser_cancel.add_argument('--source', required=True, help='the source address')
parser_cancel.add_argument('--offer-hash', required=True, help='the transaction hash of the order or bet')
parser_cancel.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_rps = subparsers.add_parser('rps', help='open a rock-paper-scissors like game')
parser_rps.add_argument('--source', required=True, help='the source address')
parser_rps.add_argument('--wager', required=True, help='the quantity of XCP to wager')
parser_rps.add_argument('--move', type=int, required=True, help='the selected move')
parser_rps.add_argument('--possible-moves', type=int, required=True, help='the number of possible moves (odd number greater or equal than 3)')
parser_rps.add_argument('--expiration', type=int, required=True, help='the number of blocks for which the bet should be valid')
parser_rps.add_argument('--fee', help='the exact BTC fee to be paid to miners')
parser_rpsresolve = subparsers.add_parser('rpsresolve', help='resolve a rock-paper-scissors like game')
parser_rpsresolve.add_argument('--source', required=True, help='the source address')
parser_rpsresolve.add_argument('--random', type=str, required=True, help='the random number used in the corresponding rps transaction')
parser_rpsresolve.add_argument('--move', type=int, required=True, help='the selected move in the corresponding rps transaction')
parser_rpsresolve.add_argument('--rps-match-id', required=True, help='the concatenation of the hashes of the two transactions which compose the rps match')
parser_rpsresolve.add_argument('--fee', help='the exact BTC fee to be paid to miners')
parser_publish = subparsers.add_parser('publish', help='publish contract code in the blockchain')
parser_publish.add_argument('--source', required=True, help='the source address')
parser_publish.add_argument('--gasprice', required=True, type=int, help='the price of gas')
parser_publish.add_argument('--startgas', required=True, type=int, help='the maximum quantity of {} to be used to pay for the execution (satoshis)'.format(config.XCP))
parser_publish.add_argument('--endowment', required=True, type=int, help='quantity of {} to be transfered to the contract (satoshis)'.format(config.XCP))
parser_publish.add_argument('--code-hex', required=True, type=str, help='the hex‐encoded contract (returned by `serpent compile`)')
parser_publish.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_execute = subparsers.add_parser('execute', help='execute contract code in the blockchain')
parser_execute.add_argument('--source', required=True, help='the source address')
parser_execute.add_argument('--contract-id', required=True, help='the contract ID of the contract to be executed')
parser_execute.add_argument('--gasprice', required=True, type=int, help='the price of gas')
parser_execute.add_argument('--startgas', required=True, type=int, help='the maximum quantity of {} to be used to pay for the execution (satoshis)'.format(config.XCP))
parser_execute.add_argument('--value', required=True, type=int, help='quantity of {} to be transfered to the contract (satoshis)'.format(config.XCP))
parser_execute.add_argument('--payload-hex', required=True, type=str, help='data to be provided to the contract (returned by `serpent encode_datalist`)')
parser_execute.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_destroy = subparsers.add_parser('destroy', help='destroy a quantity of a Counterparty asset')
parser_destroy.add_argument('--source', required=True, help='the source address')
parser_destroy.add_argument('--asset', required=True, help='the ASSET of which you would like to destroy QUANTITY')
parser_destroy.add_argument('--quantity', required=True, help='the quantity of ASSET to destroy')
parser_destroy.add_argument('--tag', default='', help='tag')
parser_destroy.add_argument('--fee', help='the exact {} fee to be paid to miners'.format(config.BTC))
parser_address = subparsers.add_parser('balances', help='display the balances of a {} address'.format(config.XCP_NAME))
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 {} asset'.format(config.XCP_NAME))
parser_asset.add_argument('asset', help='the asset you are interested in')
parser_wallet = subparsers.add_parser('wallet', help='list the addresses in your backend wallet along with their balances in all {} assets'.format(config.XCP_NAME))
parser_pending = subparsers.add_parser('pending', help='list pending order matches awaiting {}payment from you'.format(config.BTC))
parser_getrows = subparsers.add_parser('getrows', help='get rows from a Counterparty table')
parser_getrows.add_argument('--table', required=True, help='table name')
parser_getrows.add_argument('--filter', nargs=3, action='append', help='filters to get specific rows')
parser_getrows.add_argument('--filter-op', choices=['AND', 'OR'], help='operator uses to combine filters', default='AND')
parser_getrows.add_argument('--order-by', help='field used to order results')
parser_getrows.add_argument('--order-dir', choices=['ASC', 'DESC'], help='direction used to order results')
parser_getrows.add_argument('--start-block', help='return only rows with block_index greater than start-block')
parser_getrows.add_argument('--end-block', help='return only rows with block_index lower than end-block')
parser_getrows.add_argument('--status', help='return only rows with the specified status')
parser_getrows.add_argument('--limit', help='number of rows to return', default=100)
parser_getrows.add_argument('--offset', help='number of rows to skip', default=0)
parser_getrunninginfo = subparsers.add_parser('getinfo', help='get the current state of the server')
args = parser.parse_args()
# Logging
log.set_up(logger, verbose=args.verbose)
logger.propagate = False
logger.info('Running v{} of {}.'.format(APP_VERSION, APP_NAME))
# Help message
if args.help:
parser.print_help()
sys.exit()
# Configuration
clientapi.initialize(testnet=args.testnet, testcoin=args.testcoin,
counterparty_rpc_connect=args.counterparty_rpc_connect, counterparty_rpc_port=args.counterparty_rpc_port,
counterparty_rpc_user=args.counterparty_rpc_user, counterparty_rpc_password=args.counterparty_rpc_password,
counterparty_rpc_ssl=args.counterparty_rpc_ssl, counterparty_rpc_ssl_verify=args.counterparty_rpc_ssl_verify,
wallet_name=args.wallet_name, wallet_connect=args.wallet_connect, wallet_port=args.wallet_port,
wallet_user=args.wallet_user, wallet_password=args.wallet_password,
wallet_ssl=args.wallet_ssl, wallet_ssl_verify=args.wallet_ssl_verify,
requests_timeout=args.requests_timeout)
# MESSAGE CREATION
if args.action in list(messages.MESSAGE_PARAMS.keys()):
unsigned_hex = messages.compose(args.action, args)
logger.info('Transaction (unsigned): {}'.format(unsigned_hex))
if not args.unsigned:
if script.is_multisig(args.source):
logger.info('Multi‐signature transactions are signed and broadcasted manually.')
elif input('Sign and broadcast? (y/N) ') == 'y':
if wallet.is_mine(args.source):
if wallet.is_locked():
passphrase = getpass.getpass('Enter your wallet passhrase: ')
logger.info('Unlocking wallet for 60 (more) seconds.')
wallet.unlock(passphrase)
signed_tx_hex = wallet.sign_raw_transaction(unsigned_hex)
else:
private_key_wif = input('Source address not in wallet. Please enter the private key in WIF format for {}:'.format(args.source))
if not private_key_wif:
raise TransactionError('invalid private key')
signed_tx_hex = wallet.sign_raw_transaction(unsigned_hex, private_key_wif=private_key_wif)
logger.info('Transaction (signed): {}'.format(signed_tx_hex))
tx_hash = wallet.send_raw_transaction(signed_tx_hex)
logger.info('Hash of transaction (broadcasted): {}'.format(tx_hash))
# VIEWING
elif args.action in ['balances', 'asset', 'wallet', 'pending', 'getinfo', 'getrows']:
view = console.get_view(args.action, args)
print_method = getattr(console, 'print_{}'.format(args.action), None)
if args.json_output or print_method is None:
util.json_print(view)
else:
print_method(view)
else:
parser.print_help()
def get_unspent_txouts(source,
unconfirmed=False,
multisig_inputs=False,
unspent_tx_hash=None):
"""returns a list of unspent outputs for a specific address
@return: A list of dicts, with each entry in the dict having the following keys:
"""
if not MEMPOOL_CACHE_INITIALIZED:
raise MempoolError(
'Mempool is not yet ready; please try again in a few minutes.')
# Get all outputs.
logger.debug('Getting outputs for {}'.format(source))
if unspent_tx_hash:
raw_transactions = [getrawtransaction(unspent_tx_hash, verbose=True)]
else:
if script.is_multisig(source):
pubkeyhashes = script.pubkeyhash_array(source)
raw_transactions = searchrawtransactions(
pubkeyhashes[1], unconfirmed=True
) # unconfirmed=True to prune unconfirmed spent outputs
else:
pubkeyhashes = [source]
raw_transactions = searchrawtransactions(source, unconfirmed=True)
# Change format.
# TODO: Slow.
logger.debug('Formatting outputs for {}'.format(source))
outputs = {}
for tx in raw_transactions:
for vout in tx['vout']:
txid = tx['txid']
confirmations = tx['confirmations'] if 'confirmations' in tx else 0
outkey = '{}{}'.format(
txid, vout['n']) # edge case: avoid duplicate output
if outkey not in outputs or outputs[outkey][
'confirmations'] < confirmations:
coin = {
'amount': float(vout['value']),
'confirmations': confirmations,
'scriptPubKey': vout['scriptPubKey']['hex'],
'txid': txid,
'vout': vout['n']
}
outputs[outkey] = coin
outputs = sorted(outputs.values(), key=lambda x: x['confirmations'])
# Prune unspendable.
logger.debug('Pruning unspendable outputs for {}'.format(source))
# TODO: Slow.
outputs = [
output for output in outputs
if is_scriptpubkey_spendable(output['scriptPubKey'], source)
]
# Prune spent outputs.
logger.debug('Pruning spent outputs for {}'.format(source))
vins = {(vin['txid'], vin['vout'])
for tx in raw_transactions for vin in tx['vin']
if 'coinbase' not in vin}
unspent = []
for output in outputs:
if (output['txid'], output['vout']) not in vins:
unspent.append(output)
unspent = sorted(unspent, key=lambda x: x['txid'])
# Remove unconfirmed txouts, if desired.
if not unconfirmed:
unspent = [output for output in unspent if output['confirmations'] > 0]
else:
# Hackish: Allow only inputs which are either already confirmed or were seen only recently. (Skip outputs from slow‐to‐confirm transanctions.)
try:
unspent = [
output for output in unspent
if output['confirmations'] > 0 or (time.time() -
output['ts']) < 6 * 3600
] # Cutoff: six hours
except (KeyError, TypeError):
pass
return unspent
def construct (db, tx_info, encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
estimate_fee_per_kb=None, estimate_fee_per_kb_nblocks=config.ESTIMATE_FEE_NBLOCKS,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None, fee_provided=0, provided_pubkeys=None, dust_return_pubkey=None,
allow_unconfirmed_inputs=False, unspent_tx_hash=None, custom_inputs=None, disable_utxo_locks=False):
if estimate_fee_per_kb is None:
estimate_fee_per_kb = config.ESTIMATE_FEE_PER_KB
global UTXO_LOCKS
desired_encoding = encoding
(source, destination_outputs, data) = tx_info
if dust_return_pubkey:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey)
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
source_is_p2sh = script.is_p2sh(source)
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
if UTXO_LOCKS is None and config.UTXO_LOCKS_MAX_ADDRESSES > 0: # initialize if configured
UTXO_LOCKS = util.DictCache(size=config.UTXO_LOCKS_MAX_ADDRESSES)
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError('Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append((backend.multisig_pubkeyhashes_to_pubkeys(address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum([value for address, value in destination_outputs])
'''Data'''
if data:
# Data encoding methods (choose and validate).
if encoding == 'auto':
if len(data) + len(config.PREFIX) <= config.OP_RETURN_MAX_SIZE:
encoding = 'opreturn'
else:
encoding = 'multisig'
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
if encoding == 'multisig':
# dust_return_pubkey should be set or explicitly set to False to use the default configured for the node
# the default for the node is optional so could fail
if (source_is_p2sh and dust_return_pubkey is None) or (dust_return_pubkey is False and config.P2SH_DUST_RETURN_PUBKEY is None):
raise exceptions.TransactionError("Can't use multisig encoding when source is P2SH and no dust_return_pubkey is provided.")
elif dust_return_pubkey is False:
dust_return_pubkey = binascii.unhexlify(config.P2SH_DUST_RETURN_PUBKEY)
# Divide data into chunks.
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) + len(config.PREFIX) > chunk_size:
raise exceptions.TransactionError('One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
# Data outputs.
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
if not dust_return_pubkey:
if encoding == 'multisig':
dust_return_pubkey = get_dust_return_pubkey(source, provided_pubkeys, encoding)
else:
dust_return_pubkey = None
else:
data_array = []
data_output = None
dust_return_pubkey = None
data_btc_out = sum([data_value for data_chunk in data_array])
'''Inputs'''
# Calculate collective size of outputs, for fee calculation.
p2pkhsize = 25 + 9
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
data_output_size = 90 # 80 for the data
else:
data_output_size = p2pkhsize # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = (p2pkhsize * len(destination_outputs)) + (len(data_array) * data_output_size)
# Get inputs.
multisig_inputs = not data
use_inputs = custom_inputs # Array of UTXOs, as retrieved by listunspent function from bitcoind
if custom_inputs is None:
if unspent_tx_hash is not None:
unspent = backend.get_unspent_txouts(source, unconfirmed=allow_unconfirmed_inputs, unspent_tx_hash=unspent_tx_hash, multisig_inputs=multisig_inputs)
else:
unspent = backend.get_unspent_txouts(source, unconfirmed=allow_unconfirmed_inputs, multisig_inputs=multisig_inputs)
# filter out any locked UTXOs to prevent creating transactions that spend the same UTXO when they're created at the same time
if UTXO_LOCKS is not None and source in UTXO_LOCKS:
unspentkeys = {make_outkey(output) for output in unspent}
filtered_unspentkeys = unspentkeys - UTXO_LOCKS[source].keys()
unspent = [output for output in unspent if make_outkey(output) in filtered_unspentkeys]
unspent = backend.sort_unspent_txouts(unspent)
logger.debug('Sorted candidate UTXOs: {}'.format([print_coin(coin) for coin in unspent]))
use_inputs = unspent
# use backend estimated fee_per_kb
if estimate_fee_per_kb:
estimated_fee_per_kb = backend.fee_per_kb(estimate_fee_per_kb_nblocks)
if estimated_fee_per_kb is not None:
fee_per_kb = max(estimated_fee_per_kb, fee_per_kb) # never drop below the default fee_per_kb
logger.debug('Fee/KB {:.8f}'.format(fee_per_kb / config.UNIT))
inputs = []
btc_in = 0
change_quantity = 0
sufficient_funds = False
final_fee = fee_per_kb
desired_input_count = 1
if encoding == 'multisig' and data_array and util.enabled('bytespersigop'):
desired_input_count = len(data_array) * 2
for coin in use_inputs:
logger.debug('New input: {}'.format(print_coin(coin)))
inputs.append(coin)
btc_in += round(coin['amount'] * config.UNIT)
size = 181 * len(inputs) + outputs_size + 10
necessary_fee = int(size / 1000 * fee_per_kb)
# If exact fee is specified, use that. Otherwise, calculate size of tx
# and base fee on that (plus provide a minimum fee for selling BTC).
if exact_fee:
final_fee = exact_fee
else:
final_fee = max(fee_provided, necessary_fee)
# Check if good.
btc_out = destination_btc_out + data_btc_out
change_quantity = btc_in - (btc_out + final_fee)
logger.debug('Size: {} Fee: {:.8f} Change quantity: {:.8f} BTC'.format(size, final_fee / config.UNIT, change_quantity / config.UNIT))
# If change is necessary, must not be a dust output.
if change_quantity == 0 or change_quantity >= regular_dust_size:
sufficient_funds = True
if len(inputs) >= desired_input_count:
break
if not sufficient_funds:
# Approximate needed change, fee by with most recently calculated
# quantities.
btc_out = destination_btc_out + data_btc_out
total_btc_out = btc_out + max(change_quantity, 0) + final_fee
raise exceptions.BalanceError('Insufficient {} at address {}. (Need approximately {} {}.) To spend unconfirmed coins, use the flag `--unconfirmed`. (Unconfirmed coins cannot be spent from multi‐sig addresses.)'.format(config.BTC, source, total_btc_out / config.UNIT, config.BTC))
# Lock the source's inputs (UTXOs) chosen for this transaction
if UTXO_LOCKS is not None and not disable_utxo_locks:
if source not in UTXO_LOCKS:
UTXO_LOCKS[source] = cachetools.TTLCache(
UTXO_LOCKS_PER_ADDRESS_MAXSIZE, config.UTXO_LOCKS_MAX_AGE)
for input in inputs:
UTXO_LOCKS[source][make_outkey(input)] = input
logger.debug("UTXO locks: Potentials ({}): {}, Used: {}, locked UTXOs: {}".format(
len(unspent), [make_outkey(coin) for coin in unspent],
[make_outkey(input) for input in inputs], list(UTXO_LOCKS[source].keys())))
'''Finish'''
# Change output.
if change_quantity:
if script.is_multisig(source):
change_address = backend.multisig_pubkeyhashes_to_pubkeys(source, provided_pubkeys)
else:
change_address = source
change_output = (change_address, change_quantity)
else:
change_output = None
# in bitcoin core v0.12.1 a -bytespersigop was added that messes with bare multisig transactions,
# as a safeguard we fall back to pubkeyhash encoding when unsure
# when len(inputs) > len(data_outputs) there's more bytes:sigops ratio and we can safely continue
if encoding == 'multisig' and inputs and data_output and len(inputs) < len(data_array) * 2 and util.enabled('bytespersigop'):
# if auto encoding we can do pubkeyhash encoding instead
if desired_encoding == 'auto':
return construct(db, tx_info,
encoding='pubkeyhash',
fee_per_kb=fee_per_kb,
regular_dust_size=regular_dust_size,
multisig_dust_size=multisig_dust_size,
op_return_value=op_return_value,
exact_fee=exact_fee, fee_provided=fee_provided, provided_pubkeys=provided_pubkeys,
allow_unconfirmed_inputs=allow_unconfirmed_inputs, unspent_tx_hash=unspent_tx_hash, custom_inputs=custom_inputs)
# otherwise raise exception
else:
raise exceptions.EncodingError("multisig will be rejected by Bitcoin Core >= v0.12.1, you should use `encoding=auto` or `encoding=pubkeyhash`")
# Serialise inputs and outputs.
unsigned_tx = serialise(encoding, inputs, destination_outputs,
data_output, change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
from counterpartylib.lib import blocks
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(desired_destination_outputs[0][0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
parsed_source, parsed_destination, x, y, parsed_data = blocks._get_tx_info(unsigned_tx_hex)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
return unsigned_tx_hex
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
desired = (desired_source, desired_destination, desired_data)
parsed = (parsed_source, parsed_destination, parsed_data)
if desired != parsed:
# Unlock (revert) UTXO locks
if UTXO_LOCKS is not None:
for input in inputs:
UTXO_LOCKS[source].pop(make_outkey(input), None)
raise exceptions.TransactionError('Constructed transaction does not parse correctly: {} ≠ {}'.format(desired, parsed))
return unsigned_tx_hex
def construct(db,
tx_info,
encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
estimate_fee_per_kb=None,
estimate_fee_per_kb_nblocks=config.ESTIMATE_FEE_NBLOCKS,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None,
fee_provided=0,
provided_pubkeys=None,
dust_return_pubkey=None,
allow_unconfirmed_inputs=False,
unspent_tx_hash=None,
custom_inputs=None,
disable_utxo_locks=False):
if estimate_fee_per_kb is None:
estimate_fee_per_kb = config.ESTIMATE_FEE_PER_KB
global UTXO_LOCKS
desired_encoding = encoding
(source, destination_outputs, data) = tx_info
if dust_return_pubkey:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey)
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
source_is_p2sh = script.is_p2sh(source)
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
if UTXO_LOCKS is None and config.UTXO_LOCKS_MAX_ADDRESSES > 0: # initialize if configured
UTXO_LOCKS = util.DictCache(size=config.UTXO_LOCKS_MAX_ADDRESSES)
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError('Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append(
(backend.multisig_pubkeyhashes_to_pubkeys(
address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum(
[value for address, value in destination_outputs])
'''Data'''
if data:
# Data encoding methods (choose and validate).
if encoding == 'auto':
if len(data) + len(config.PREFIX) <= config.OP_RETURN_MAX_SIZE:
encoding = 'opreturn'
else:
encoding = 'multisig'
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
if encoding == 'multisig':
# dust_return_pubkey should be set or explicitly set to False to use the default configured for the node
# the default for the node is optional so could fail
if (source_is_p2sh and dust_return_pubkey is None) or (
dust_return_pubkey is False
and config.P2SH_DUST_RETURN_PUBKEY is None):
raise exceptions.TransactionError(
"Can't use multisig encoding when source is P2SH and no dust_return_pubkey is provided."
)
elif dust_return_pubkey is False:
dust_return_pubkey = binascii.unhexlify(
config.P2SH_DUST_RETURN_PUBKEY)
# Divide data into chunks.
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) + len(config.PREFIX) > chunk_size:
raise exceptions.TransactionError(
'One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
# Data outputs.
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
if not dust_return_pubkey:
if encoding == 'multisig':
dust_return_pubkey = get_dust_return_pubkey(
source, provided_pubkeys, encoding)
else:
dust_return_pubkey = None
else:
data_array = []
data_output = None
dust_return_pubkey = None
data_btc_out = sum([data_value for data_chunk in data_array])
'''Inputs'''
# Calculate collective size of outputs, for fee calculation.
p2pkhsize = 25 + 9
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
data_output_size = 90 # 80 for the data
else:
data_output_size = p2pkhsize # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = (p2pkhsize * len(destination_outputs)) + (len(data_array) *
data_output_size)
# Get inputs.
multisig_inputs = not data
use_inputs = custom_inputs # Array of UTXOs, as retrieved by listunspent function from bitcoind
if custom_inputs is None:
if unspent_tx_hash is not None:
unspent = backend.get_unspent_txouts(
source,
unconfirmed=allow_unconfirmed_inputs,
unspent_tx_hash=unspent_tx_hash,
multisig_inputs=multisig_inputs)
else:
unspent = backend.get_unspent_txouts(
source,
unconfirmed=allow_unconfirmed_inputs,
multisig_inputs=multisig_inputs)
# filter out any locked UTXOs to prevent creating transactions that spend the same UTXO when they're created at the same time
if UTXO_LOCKS is not None and source in UTXO_LOCKS:
unspentkeys = {make_outkey(output) for output in unspent}
filtered_unspentkeys = unspentkeys - UTXO_LOCKS[source].keys()
unspent = [
output for output in unspent
if make_outkey(output) in filtered_unspentkeys
]
unspent = backend.sort_unspent_txouts(unspent)
logger.debug('Sorted candidate UTXOs: {}'.format(
[print_coin(coin) for coin in unspent]))
use_inputs = unspent
# use backend estimated fee_per_kb
if estimate_fee_per_kb:
estimated_fee_per_kb = backend.fee_per_kb(estimate_fee_per_kb_nblocks)
if estimated_fee_per_kb is not None:
fee_per_kb = max(
estimated_fee_per_kb,
fee_per_kb) # never drop below the default fee_per_kb
logger.debug('Fee/KB {:.8f}'.format(fee_per_kb / config.UNIT))
inputs = []
btc_in = 0
change_quantity = 0
sufficient_funds = False
final_fee = fee_per_kb
desired_input_count = 1
if encoding == 'multisig' and data_array and util.enabled('bytespersigop'):
desired_input_count = len(data_array) * 2
for coin in use_inputs:
logger.debug('New input: {}'.format(print_coin(coin)))
inputs.append(coin)
btc_in += round(coin['amount'] * config.UNIT)
size = 181 * len(inputs) + outputs_size + 10
necessary_fee = int(size / 1000 * fee_per_kb)
# If exact fee is specified, use that. Otherwise, calculate size of tx
# and base fee on that (plus provide a minimum fee for selling BTC).
if exact_fee:
final_fee = exact_fee
else:
final_fee = max(fee_provided, necessary_fee)
# Check if good.
btc_out = destination_btc_out + data_btc_out
change_quantity = btc_in - (btc_out + final_fee)
logger.debug('Size: {} Fee: {:.8f} Change quantity: {:.8f} BTC'.format(
size, final_fee / config.UNIT, change_quantity / config.UNIT))
# If change is necessary, must not be a dust output.
if change_quantity == 0 or change_quantity >= regular_dust_size:
sufficient_funds = True
if len(inputs) >= desired_input_count:
break
if not sufficient_funds:
# Approximate needed change, fee by with most recently calculated
# quantities.
btc_out = destination_btc_out + data_btc_out
total_btc_out = btc_out + max(change_quantity, 0) + final_fee
raise exceptions.BalanceError(
'Insufficient {} at address {}. (Need approximately {} {}.) To spend unconfirmed coins, use the flag `--unconfirmed`. (Unconfirmed coins cannot be spent from multi‐sig addresses.)'
.format(config.BTC, source, total_btc_out / config.UNIT,
config.BTC))
# Lock the source's inputs (UTXOs) chosen for this transaction
if UTXO_LOCKS is not None and not disable_utxo_locks:
if source not in UTXO_LOCKS:
UTXO_LOCKS[source] = cachetools.TTLCache(
UTXO_LOCKS_PER_ADDRESS_MAXSIZE, config.UTXO_LOCKS_MAX_AGE)
for input in inputs:
UTXO_LOCKS[source][make_outkey(input)] = input
logger.debug(
"UTXO locks: Potentials ({}): {}, Used: {}, locked UTXOs: {}".
format(len(unspent), [make_outkey(coin) for coin in unspent],
[make_outkey(input) for input in inputs],
list(UTXO_LOCKS[source].keys())))
'''Finish'''
# Change output.
if change_quantity:
if script.is_multisig(source):
change_address = backend.multisig_pubkeyhashes_to_pubkeys(
source, provided_pubkeys)
else:
change_address = source
change_output = (change_address, change_quantity)
else:
change_output = None
# in bitcoin core v0.12.1 a -bytespersigop was added that messes with bare multisig transactions,
# as a safeguard we fall back to pubkeyhash encoding when unsure
# when len(inputs) > len(data_outputs) there's more bytes:sigops ratio and we can safely continue
if encoding == 'multisig' and inputs and data_output and len(
inputs) < len(data_array) * 2 and util.enabled('bytespersigop'):
# if auto encoding we can do pubkeyhash encoding instead
if desired_encoding == 'auto':
return construct(db,
tx_info,
encoding='pubkeyhash',
fee_per_kb=fee_per_kb,
regular_dust_size=regular_dust_size,
multisig_dust_size=multisig_dust_size,
op_return_value=op_return_value,
exact_fee=exact_fee,
fee_provided=fee_provided,
provided_pubkeys=provided_pubkeys,
allow_unconfirmed_inputs=allow_unconfirmed_inputs,
unspent_tx_hash=unspent_tx_hash,
custom_inputs=custom_inputs)
# otherwise raise exception
else:
raise exceptions.EncodingError(
"multisig will be rejected by Bitcoin Core >= v0.12.1, you should use `encoding=auto` or `encoding=pubkeyhash`"
)
# Serialise inputs and outputs.
unsigned_tx = serialise(encoding,
inputs,
destination_outputs,
data_output,
change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
from counterpartylib.lib import blocks
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(
desired_destination_outputs[0]
[0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
parsed_source, parsed_destination, x, y, parsed_data = blocks._get_tx_info(
unsigned_tx_hex)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
return unsigned_tx_hex
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
desired = (desired_source, desired_destination, desired_data)
parsed = (parsed_source, parsed_destination, parsed_data)
if desired != parsed:
# Unlock (revert) UTXO locks
if UTXO_LOCKS is not None:
for input in inputs:
UTXO_LOCKS[source].pop(make_outkey(input), None)
raise exceptions.TransactionError(
'Constructed transaction does not parse correctly: {} ≠ {}'.format(
desired, parsed))
return unsigned_tx_hex
def serialise(encoding,
inputs,
destination_outputs,
data_output=None,
change_output=None,
dust_return_pubkey=None):
s = (1).to_bytes(4, byteorder='little') # Version
# Number of inputs.
s += var_int(int(len(inputs)))
# List of Inputs.
for i in range(len(inputs)):
txin = inputs[i]
s += binascii.unhexlify(bytes(txin['txid'],
'utf-8'))[::-1] # TxOutHash
s += txin['vout'].to_bytes(4, byteorder='little') # TxOutIndex
tx_script = binascii.unhexlify(bytes(txin['scriptPubKey'], 'utf-8'))
s += var_int(int(len(tx_script))) # Script length
s += tx_script # Script
s += b'\xff' * 4 # Sequence
# Number of outputs.
n = 0
n += len(destination_outputs)
if data_output:
data_array, value = data_output
for data_chunk in data_array:
n += 1
else:
data_array = []
if change_output: n += 1
s += var_int(n)
# Destination output.
for destination, value in destination_outputs:
s += value.to_bytes(8, byteorder='little') # Value
if script.is_multisig(destination):
tx_script = get_multisig_script(destination)
else:
tx_script = get_monosig_script(destination)
s += var_int(int(len(tx_script))) # Script length
s += tx_script
# Data output.
for data_chunk in data_array:
data_array, value = data_output
s += value.to_bytes(8, byteorder='little') # Value
if util.enabled('multisig_addresses'): # Protocol change.
data_chunk = config.PREFIX + data_chunk
# Initialise encryption key (once per output).
key = ARC4.new(binascii.unhexlify(
inputs[0]['txid'])) # Arbitrary, easy‐to‐find, unique key.
if encoding == 'multisig':
# Get data (fake) public key.
if util.enabled('multisig_addresses'): # Protocol change.
pad_length = (33 * 2) - 1 - 2 - 2 - len(data_chunk)
assert pad_length >= 0
data_chunk = bytes([len(data_chunk)
]) + data_chunk + (pad_length * b'\x00')
data_chunk = key.encrypt(data_chunk)
data_pubkey_1 = make_fully_valid(data_chunk[:31])
data_pubkey_2 = make_fully_valid(data_chunk[31:])
# Construct script.
tx_script = OP_1 # OP_1
tx_script += op_push(
33) # Push bytes of data chunk (fake) public key (1/2)
tx_script += data_pubkey_1 # (Fake) public key (1/2)
tx_script += op_push(
33) # Push bytes of data chunk (fake) public key (2/2)
tx_script += data_pubkey_2 # (Fake) public key (2/2)
tx_script += op_push(
len(dust_return_pubkey)) # Push bytes of source public key
tx_script += dust_return_pubkey # Source public key
tx_script += OP_3 # OP_3
tx_script += OP_CHECKMULTISIG # OP_CHECKMULTISIG
else:
pad_length = 33 - 1 - len(data_chunk)
assert pad_length >= 0
data_chunk = bytes([len(data_chunk)
]) + data_chunk + (pad_length * b'\x00')
# Construct script.
tx_script = OP_1 # OP_1
tx_script += op_push(
len(dust_return_pubkey)) # Push bytes of source public key
tx_script += dust_return_pubkey # Source public key
tx_script += op_push(len(
data_chunk)) # Push bytes of data chunk (fake) public key
tx_script += data_chunk # (Fake) public key
tx_script += OP_2 # OP_2
tx_script += OP_CHECKMULTISIG # OP_CHECKMULTISIG
elif encoding == 'opreturn':
if util.enabled('multisig_addresses'): # Protocol change.
data_chunk = key.encrypt(data_chunk)
tx_script = OP_RETURN # OP_RETURN
tx_script += op_push(len(
data_chunk)) # Push bytes of data chunk (NOTE: OP_SMALLDATA?)
tx_script += data_chunk # Data
elif encoding == 'pubkeyhash':
pad_length = 20 - 1 - len(data_chunk)
assert pad_length >= 0
data_chunk = bytes([len(data_chunk)
]) + data_chunk + (pad_length * b'\x00')
data_chunk = key.encrypt(data_chunk)
# Construct script.
tx_script = OP_DUP # OP_DUP
tx_script += OP_HASH160 # OP_HASH160
tx_script += op_push(20) # Push 0x14 bytes
tx_script += data_chunk # (Fake) pubKeyHash
tx_script += OP_EQUALVERIFY # OP_EQUALVERIFY
tx_script += OP_CHECKSIG # OP_CHECKSIG
else:
raise exceptions.TransactionError('Unknown encoding‐scheme.')
s += var_int(int(len(tx_script))) # Script length
s += tx_script
# Change output.
if change_output:
change_address, change_value = change_output
s += change_value.to_bytes(8, byteorder='little') # Value
if script.is_multisig(change_address):
tx_script = get_multisig_script(change_address)
else:
tx_script = get_monosig_script(change_address)
s += var_int(int(len(tx_script))) # Script length
s += tx_script
s += (0).to_bytes(4, byteorder='little') # LockTime
return s
def construct(
db,
tx_info,
encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
estimate_fee_per_kb=None,
estimate_fee_per_kb_conf_target=config.ESTIMATE_FEE_CONF_TARGET,
estimate_fee_per_kb_mode=config.ESTIMATE_FEE_MODE,
estimate_fee_per_kb_nblocks=config.ESTIMATE_FEE_CONF_TARGET,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None,
fee_provided=0,
provided_pubkeys=None,
dust_return_pubkey=None,
allow_unconfirmed_inputs=False,
unspent_tx_hash=None,
custom_inputs=None,
disable_utxo_locks=False,
extended_tx_info=False,
old_style_api=None,
segwit=False,
p2sh_source_multisig_pubkeys=None,
p2sh_source_multisig_pubkeys_required=None,
p2sh_pretx_txid=None,
):
if estimate_fee_per_kb is None:
estimate_fee_per_kb = config.ESTIMATE_FEE_PER_KB
global UTXO_LOCKS, UTXO_P2SH_ENCODING_LOCKS
# lazy assign from config, because when set as default it's evaluated before it's configured
if old_style_api is None:
old_style_api = config.OLD_STYLE_API
(source, destination_outputs, data) = tx_info
if dust_return_pubkey:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey)
if p2sh_source_multisig_pubkeys:
p2sh_source_multisig_pubkeys = [
binascii.unhexlify(p) for p in p2sh_source_multisig_pubkeys
]
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
source_is_p2sh = script.is_p2sh(source)
# Normalize source
if script.is_multisig(source):
source_address = backend.multisig_pubkeyhashes_to_pubkeys(
source, provided_pubkeys)
else:
source_address = source
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
'''Determine encoding method'''
if data:
desired_encoding = encoding
# Data encoding methods (choose and validate).
if desired_encoding == 'auto':
if len(data) + len(config.PREFIX) <= config.OP_RETURN_MAX_SIZE:
encoding = 'opreturn'
else:
encoding = 'p2sh' if not old_style_api and util.enabled(
'p2sh_encoding'
) else 'multisig' # p2sh is not possible with old_style_api
elif desired_encoding == 'p2sh' and not util.enabled('p2sh_encoding'):
raise exceptions.TransactionError('P2SH encoding not enabled yet')
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn', 'p2sh'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
else:
# no data
encoding = None
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
if encoding != 'p2sh':
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError(
'Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append(
(backend.multisig_pubkeyhashes_to_pubkeys(
address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum(
[value for address, value in destination_outputs])
'''Data'''
if data:
# @TODO: p2sh encoding require signable dust key
if encoding == 'multisig':
# dust_return_pubkey should be set or explicitly set to False to use the default configured for the node
# the default for the node is optional so could fail
if (source_is_p2sh and dust_return_pubkey is None) or (
dust_return_pubkey is False
and config.P2SH_DUST_RETURN_PUBKEY is None):
raise exceptions.TransactionError(
"Can't use multisig encoding when source is P2SH and no dust_return_pubkey is provided."
)
elif dust_return_pubkey is False:
dust_return_pubkey = binascii.unhexlify(
config.P2SH_DUST_RETURN_PUBKEY)
# Divide data into chunks.
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'p2sh':
chunk_size = p2sh_encoding.maximum_data_chunk_size()
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) + len(config.PREFIX) > chunk_size:
raise exceptions.TransactionError(
'One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
# Data outputs.
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'p2sh':
data_value = 0 # this will be calculated later
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
if not dust_return_pubkey:
if encoding == 'multisig' or encoding == 'p2sh' and not source_is_p2sh:
dust_return_pubkey = get_dust_return_pubkey(
source, provided_pubkeys, encoding)
else:
dust_return_pubkey = None
else:
data_value = 0
data_array = []
data_output = None
dust_return_pubkey = None
data_btc_out = data_value * len(data_array)
logger.getChild('p2shdebug').debug(
'data_btc_out=%s (data_value=%d len(data_array)=%d)' %
(data_btc_out, data_value, len(data_array)))
'''Inputs'''
btc_in = 0
final_fee = 0
# Calculate collective size of outputs, for fee calculation.
p2pkhsize = 25 + 9
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
# prefix + data + 10 bytes script overhead
data_output_size = len(config.PREFIX) + 10
if data is not None:
data_output_size = data_output_size + len(data)
else:
data_output_size = p2pkhsize # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = (p2pkhsize * len(destination_outputs)) + (len(data_array) *
data_output_size)
if encoding == 'p2sh':
# calculate all the p2sh outputs
size_for_fee, datatx_necessary_fee, data_value, data_btc_out = p2sh_encoding.calculate_outputs(
destination_outputs, data_array, fee_per_kb)
# replace the data value
data_output = (data_array, data_value)
else:
sum_data_output_size = len(data_array) * data_output_size
size_for_fee = (
(25 + 9) * len(destination_outputs)) + sum_data_output_size
if not (encoding == 'p2sh' and p2sh_pretx_txid):
inputs, change_quantity, n_btc_in, n_final_fee = construct_coin_selection(
encoding, data_array, source, allow_unconfirmed_inputs,
unspent_tx_hash, custom_inputs, fee_per_kb, estimate_fee_per_kb,
estimate_fee_per_kb_nblocks, exact_fee, size_for_fee, fee_provided,
destination_btc_out, data_btc_out, regular_dust_size,
disable_utxo_locks)
btc_in = n_btc_in
final_fee = n_final_fee
else:
# when encoding is P2SH and the pretx txid is passed we can skip coinselection
inputs, change_quantity = None, None
'''Finish'''
if change_quantity:
change_output = (source_address, change_quantity)
else:
change_output = None
unsigned_pretx_hex = None
unsigned_tx_hex = None
pretx_txid = None
if encoding == 'p2sh':
assert not (segwit and p2sh_pretx_txid
) # shouldn't do old style with segwit enabled
if p2sh_pretx_txid:
pretx_txid = p2sh_pretx_txid if isinstance(
p2sh_pretx_txid,
bytes) else binascii.unhexlify(p2sh_pretx_txid)
unsigned_pretx = None
else:
destination_value_sum = sum(
[value for (destination, value) in destination_outputs])
source_value = destination_value_sum
if change_output:
# add the difference between source and destination to the change
change_value = change_output[1] + (destination_value_sum -
source_value)
change_output = (change_output[0], change_value)
unsigned_pretx = serializer.serialise_p2sh_pretx(
inputs,
source=source_address,
source_value=source_value,
data_output=data_output,
change_output=change_output,
pubkey=dust_return_pubkey,
multisig_pubkeys=p2sh_source_multisig_pubkeys,
multisig_pubkeys_required=p2sh_source_multisig_pubkeys_required
)
unsigned_pretx_hex = binascii.hexlify(unsigned_pretx).decode(
'utf-8')
# with segwit we already know the txid and can return both
if segwit:
#pretx_txid = hashlib.sha256(unsigned_pretx).digest() # this should be segwit txid
ptx = CTransaction.stream_deserialize(
io.BytesIO(unsigned_pretx)) # could be a non-segwit tx anyways
txid_ba = bytearray(ptx.GetTxid())
txid_ba.reverse()
pretx_txid = bytes(
txid_ba) # gonna leave the malleability problem to upstream
logger.getChild('p2shdebug').debug('pretx_txid %s' % pretx_txid)
print('pretx txid:', binascii.hexlify(pretx_txid))
if unsigned_pretx:
# we set a long lock on this, don't want other TXs to spend from it
UTXO_P2SH_ENCODING_LOCKS[make_outkey_vin(unsigned_pretx, 0)] = True
# only generate the data TX if we have the pretx txId
if pretx_txid:
source_input = None
if script.is_p2sh(source):
source_input = select_any_coin_from_source(source)
if not source_input:
raise exceptions.TransactionError(
'Unable to select source input for p2sh source address'
)
unsigned_datatx = serializer.serialise_p2sh_datatx(
pretx_txid,
source=source_address,
source_input=source_input,
destination_outputs=destination_outputs,
data_output=data_output,
pubkey=dust_return_pubkey,
multisig_pubkeys=p2sh_source_multisig_pubkeys,
multisig_pubkeys_required=p2sh_source_multisig_pubkeys_required
)
unsigned_datatx_hex = binascii.hexlify(unsigned_datatx).decode(
'utf-8')
# let the rest of the code work it's magic on the data tx
unsigned_tx_hex = unsigned_datatx_hex
else:
# we're just gonna return the pretx, it doesn't require any of the further checks
logger.warn('old_style_api = %s' % old_style_api)
return return_result([unsigned_pretx_hex],
old_style_api=old_style_api)
else:
# Serialise inputs and outputs.
unsigned_tx = serializer.serialise(
encoding,
inputs,
destination_outputs,
data_output,
change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(
desired_destination_outputs[0]
[0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
if pretx_txid and unsigned_pretx:
backend.cache_pretx(pretx_txid, unsigned_pretx)
parsed_source, parsed_destination, x, y, parsed_data, extra = blocks._get_tx_info(
unsigned_tx_hex, p2sh_is_segwit=script.is_bech32(desired_source))
if encoding == 'p2sh':
# make_canonical can't determine the address, so we blindly change the desired to the parsed
desired_source = parsed_source
if pretx_txid and unsigned_pretx:
backend.clear_pretx(pretx_txid)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
if extended_tx_info:
return {
'btc_in': btc_in,
'btc_out': destination_btc_out + data_btc_out,
'btc_change': change_quantity,
'btc_fee': final_fee,
'tx_hex': unsigned_tx_hex,
}
logger.getChild('p2shdebug').debug('BTC-ONLY')
return return_result([unsigned_pretx_hex, unsigned_tx_hex],
old_style_api=old_style_api)
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
desired = (desired_source, desired_destination, desired_data)
parsed = (parsed_source, parsed_destination, parsed_data)
if desired != parsed:
# Unlock (revert) UTXO locks
if UTXO_LOCKS is not None and inputs:
for input in inputs:
UTXO_LOCKS[source].pop(make_outkey(input), None)
raise exceptions.TransactionError(
'Constructed transaction does not parse correctly: {} ≠ {}'.format(
desired, parsed))
if extended_tx_info:
return {
'btc_in': btc_in,
'btc_out': destination_btc_out + data_btc_out,
'btc_change': change_quantity,
'btc_fee': final_fee,
'tx_hex': unsigned_tx_hex,
}
return return_result([unsigned_pretx_hex, unsigned_tx_hex],
old_style_api=old_style_api)
def construct (db, tx_info, encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None, fee_provided=0, provided_pubkeys=None,
allow_unconfirmed_inputs=False):
(source, destination_outputs, data) = tx_info
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError('Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append((backend.multisig_pubkeyhashes_to_pubkeys(address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum([value for address, value in destination_outputs])
'''Data'''
# Data encoding methods (choose and validate).
if data:
if encoding == 'auto':
if len(data) + len(config.PREFIX) <= config.OP_RETURN_MAX_SIZE:
encoding = 'opreturn'
else:
encoding = 'multisig'
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
# Divide data into chunks.
if data:
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) + len(config.PREFIX) > chunk_size:
raise exceptions.TransactionError('One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
else:
data_array = []
# Data outputs.
if data:
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
else:
data_output = None
data_btc_out = sum([data_value for data_chunk in data_array])
'''Inputs'''
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
if encoding == 'multisig':
dust_return_pubkey = get_dust_return_pubkey(source, provided_pubkeys, encoding)
else:
dust_return_pubkey = None
# Calculate collective size of outputs, for fee calculation.
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
data_output_size = 90 # 80 for the data
else:
data_output_size = 25 + 9 # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = ((25 + 9) * len(destination_outputs)) + (len(data_array) * data_output_size)
# Get inputs.
multisig_inputs = not data
unspent = backend.get_unspent_txouts(source, unconfirmed=allow_unconfirmed_inputs, multisig_inputs=multisig_inputs)
unspent = backend.sort_unspent_txouts(unspent)
logger.debug('Sorted UTXOs: {}'.format([print_coin(coin) for coin in unspent]))
inputs = []
btc_in = 0
change_quantity = 0
sufficient_funds = False
final_fee = fee_per_kb
for coin in unspent:
logger.debug('New input: {}'.format(print_coin(coin)))
inputs.append(coin)
btc_in += round(coin['amount'] * config.UNIT)
# If exact fee is specified, use that. Otherwise, calculate size of tx
# and base fee on that (plus provide a minimum fee for selling BTC).
if exact_fee:
final_fee = exact_fee
else:
size = 181 * len(inputs) + outputs_size + 10
necessary_fee = (int(size / 1000) + 1) * fee_per_kb
final_fee = max(fee_provided, necessary_fee)
assert final_fee >= 1 * fee_per_kb
# Check if good.
btc_out = destination_btc_out + data_btc_out
change_quantity = btc_in - (btc_out + final_fee)
logger.debug('Change quantity: {} BTC'.format(change_quantity / config.UNIT))
# If change is necessary, must not be a dust output.
if change_quantity == 0 or change_quantity >= regular_dust_size:
sufficient_funds = True
break
if not sufficient_funds:
# Approximate needed change, fee by with most recently calculated
# quantities.
btc_out = destination_btc_out + data_btc_out
total_btc_out = btc_out + max(change_quantity, 0) + final_fee
raise exceptions.BalanceError('Insufficient {} at address {}. (Need approximately {} {}.) To spend unconfirmed coins, use the flag `--unconfirmed`. (Unconfirmed coins cannot be spent from multi‐sig addresses.)'.format(config.BTC, source, total_btc_out / config.UNIT, config.BTC))
'''Finish'''
# Change output.
if change_quantity:
if script.is_multisig(source):
change_address = backend.multisig_pubkeyhashes_to_pubkeys(source, provided_pubkeys)
else:
change_address = source
change_output = (change_address, change_quantity)
else:
change_output = None
# Serialise inputs and outputs.
unsigned_tx = serialise(encoding, inputs, destination_outputs,
data_output, change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
from counterpartylib.lib import blocks
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(desired_destination_outputs[0][0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
parsed_source, parsed_destination, x, y, parsed_data = blocks.get_tx_info2(unsigned_tx_hex)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
return unsigned_tx_hex
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
desired = (desired_source, desired_destination, desired_data)
parsed = (parsed_source, parsed_destination, parsed_data)
if desired != parsed:
raise exceptions.TransactionError('Constructed transaction does not parse correctly: {} ≠ {}'.format(desired, parsed))
return unsigned_tx_hex
def serialise (encoding, inputs, destination_outputs, data_output=None, change_output=None, dust_return_pubkey=None):
s = (1).to_bytes(4, byteorder='little') # Version
# Number of inputs.
s += var_int(int(len(inputs)))
# List of Inputs.
for i in range(len(inputs)):
txin = inputs[i]
s += binascii.unhexlify(bytes(txin['txid'], 'utf-8'))[::-1] # TxOutHash
s += txin['vout'].to_bytes(4, byteorder='little') # TxOutIndex
tx_script = binascii.unhexlify(bytes(txin['scriptPubKey'], 'utf-8'))
s += var_int(int(len(tx_script))) # Script length
s += tx_script # Script
s += b'\xff' * 4 # Sequence
# Number of outputs.
n = 0
n += len(destination_outputs)
if data_output:
data_array, value = data_output
for data_chunk in data_array: n += 1
else:
data_array = []
if change_output: n += 1
s += var_int(n)
# Destination output.
for destination, value in destination_outputs:
s += value.to_bytes(8, byteorder='little') # Value
if script.is_multisig(destination):
tx_script = get_multisig_script(destination)
else:
tx_script = get_monosig_script(destination)
s += var_int(int(len(tx_script))) # Script length
s += tx_script
# Data output.
for data_chunk in data_array:
data_array, value = data_output
s += value.to_bytes(8, byteorder='little') # Value
data_chunk = config.PREFIX + data_chunk
# Initialise encryption key (once per output).
key = ARC4.new(binascii.unhexlify(inputs[0]['txid'])) # Arbitrary, easy‐to‐find, unique key.
if encoding == 'multisig':
assert dust_return_pubkey
# Get data (fake) public key.
pad_length = (33 * 2) - 1 - 2 - 2 - len(data_chunk)
assert pad_length >= 0
data_chunk = bytes([len(data_chunk)]) + data_chunk + (pad_length * b'\x00')
data_chunk = key.encrypt(data_chunk)
data_pubkey_1 = make_fully_valid(data_chunk[:31])
data_pubkey_2 = make_fully_valid(data_chunk[31:])
# Construct script.
tx_script = OP_1 # OP_1
tx_script += op_push(33) # Push bytes of data chunk (fake) public key (1/2)
tx_script += data_pubkey_1 # (Fake) public key (1/2)
tx_script += op_push(33) # Push bytes of data chunk (fake) public key (2/2)
tx_script += data_pubkey_2 # (Fake) public key (2/2)
tx_script += op_push(len(dust_return_pubkey)) # Push bytes of source public key
tx_script += dust_return_pubkey # Source public key
tx_script += OP_3 # OP_3
tx_script += OP_CHECKMULTISIG # OP_CHECKMULTISIG
elif encoding == 'opreturn':
data_chunk = key.encrypt(data_chunk)
tx_script = OP_RETURN # OP_RETURN
tx_script += op_push(len(data_chunk)) # Push bytes of data chunk (NOTE: OP_SMALLDATA?)
tx_script += data_chunk # Data
elif encoding == 'pubkeyhash':
pad_length = 20 - 1 - len(data_chunk)
assert pad_length >= 0
data_chunk = bytes([len(data_chunk)]) + data_chunk + (pad_length * b'\x00')
data_chunk = key.encrypt(data_chunk)
# Construct script.
tx_script = OP_DUP # OP_DUP
tx_script += OP_HASH160 # OP_HASH160
tx_script += op_push(20) # Push 0x14 bytes
tx_script += data_chunk # (Fake) pubKeyHash
tx_script += OP_EQUALVERIFY # OP_EQUALVERIFY
tx_script += OP_CHECKSIG # OP_CHECKSIG
else:
raise exceptions.TransactionError('Unknown encoding‐scheme.')
s += var_int(int(len(tx_script))) # Script length
s += tx_script
# Change output.
if change_output:
change_address, change_value = change_output
s += change_value.to_bytes(8, byteorder='little') # Value
if script.is_multisig(change_address):
tx_script = get_multisig_script(change_address)
else:
tx_script = get_monosig_script(change_address)
s += var_int(int(len(tx_script))) # Script length
s += tx_script
s += (0).to_bytes(4, byteorder='little') # LockTime
return s
def construct(db,
tx_info,
encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None,
fee_provided=0,
provided_pubkeys=None,
allow_unconfirmed_inputs=False):
(source, destination_outputs, data) = tx_info
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError('Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append(
(backend.multisig_pubkeyhashes_to_pubkeys(
address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum(
[value for address, value in destination_outputs])
'''Data'''
# Data encoding methods (choose and validate).
if data:
if encoding == 'auto':
if len(data) <= config.OP_RETURN_MAX_SIZE:
encoding = 'multisig' # BTCGuild isn’t mining `OP_RETURN`?!
else:
encoding = 'multisig'
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
# Divide data into chunks.
if data:
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) > chunk_size:
raise exceptions.TransactionError(
'One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
else:
data_array = []
# Data outputs.
if data:
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
else:
data_output = None
data_btc_out = sum([data_value for data_chunk in data_array])
'''Inputs'''
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
dust_return_pubkey = get_dust_return_pubkey(source, provided_pubkeys,
encoding)
# Calculate collective size of outputs, for fee calculation.
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
data_output_size = 90 # 80 for the data
else:
data_output_size = 25 + 9 # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = ((25 + 9) * len(destination_outputs)) + (len(data_array) *
data_output_size)
# Get inputs.
unspent = backend.get_unspent_txouts(source)
unspent = backend.sort_unspent_txouts(unspent, allow_unconfirmed_inputs)
logger.debug('Sorted UTXOs: {}'.format(
[print_coin(coin) for coin in unspent]))
inputs = []
btc_in = 0
change_quantity = 0
sufficient_funds = False
final_fee = fee_per_kb
for coin in unspent:
logger.debug('New input: {}'.format(print_coin(coin)))
inputs.append(coin)
btc_in += round(coin['amount'] * config.UNIT)
# If exact fee is specified, use that. Otherwise, calculate size of tx
# and base fee on that (plus provide a minimum fee for selling BTC).
if exact_fee:
final_fee = exact_fee
else:
size = 181 * len(inputs) + outputs_size + 10
necessary_fee = (int(size / 1000) + 1) * fee_per_kb
final_fee = max(fee_provided, necessary_fee)
assert final_fee >= 1 * fee_per_kb
# Check if good.
btc_out = destination_btc_out + data_btc_out
change_quantity = btc_in - (btc_out + final_fee)
logger.debug('Change quantity: {} BTC'.format(change_quantity /
config.UNIT))
# If change is necessary, must not be a dust output.
if change_quantity == 0 or change_quantity >= regular_dust_size:
sufficient_funds = True
break
if not sufficient_funds:
# Approximate needed change, fee by with most recently calculated
# quantities.
btc_out = destination_btc_out + data_btc_out
total_btc_out = btc_out + max(change_quantity, 0) + final_fee
raise exceptions.BalanceError(
'Insufficient {} at address {}. (Need approximately {} {}.) To spend unconfirmed coins, use the flag `--unconfirmed`. (Unconfirmed coins cannot be spent from multi‐sig addresses.)'
.format(config.BTC, source, total_btc_out / config.UNIT,
config.BTC))
'''Finish'''
# Change output.
if change_quantity:
if script.is_multisig(source):
change_address = backend.multisig_pubkeyhashes_to_pubkeys(
source, provided_pubkeys)
else:
change_address = source
change_output = (change_address, change_quantity)
else:
change_output = None
# Serialise inputs and outputs.
unsigned_tx = serialise(encoding,
inputs,
destination_outputs,
data_output,
change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
from counterpartylib.lib import blocks
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(
desired_destination_outputs[0]
[0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
parsed_source, parsed_destination, x, y, parsed_data = blocks.get_tx_info2(
unsigned_tx_hex)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
return unsigned_tx_hex
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
if (desired_source, desired_destination,
desired_data) != (parsed_source, parsed_destination, parsed_data):
raise exceptions.TransactionError(
'constructed transaction does not parse correctly')
return unsigned_tx_hex
