sendmany.py

#!/usr/bin/python3
# Copyright (C) 2015 Peter Todd <pete@petertodd.org>
#
# This file is subject to the license terms in the LICENSE file found in the
# top-level directory of this distribution.

import argparse
import binascii
import bitcoin
import bitcoin.rpc
import logging
import math

from bitcoin.core import b2x, b2lx, lx, str_money_value, COIN, CMutableTransaction, CMutableTxIn, CMutableTxOut
from bitcoin.wallet import CBitcoinAddress

DUST = int(0.0001 * COIN)

parser = argparse.ArgumentParser(description="Pay multiple recipients, taking advantage of full-RBF tx combining")
parser.add_argument('-v', action='store_true',
                    dest='verbose',
                    help='Verbose')
parser.add_argument('-t', action='store_true',
                    dest='testnet',
                    help='Enable testnet')
parser.add_argument('-n', action='store_true',
                    dest='dryrun',
                    help="Dry-run; don't actually send the transaction")
parser.add_argument('-s', action='store_true',
                    dest='first_seen_safe',
                    help="First-seen-safe rules; do not decrease the value of any txouts")
parser.add_argument('-p', action='store', type=str,
                    default=None,
                    dest='prev_txid',
                    help='Previous txid to add new output to; creates new tx if not set')
parser.add_argument('--relay-bw-feerate', action='store', type=float,
                    default=0.000011,
                    help='Relay bandwidth fee per KB')
parser.add_argument('--no-reuse', action='store_true',
                    help="Create a new tx; don't reuse an existing tx")
parser.add_argument('address', action='store', type=str,
                    help='Destination address')
parser.add_argument('amount', action='store', type=float,
                    help='Amount to send')
args = parser.parse_args()

if args.verbose:
    logging.root.setLevel('DEBUG')

if args.testnet:
    bitcoin.SelectParams('testnet')

args.amount = int(args.amount * COIN)
args.address = CBitcoinAddress(args.address)

rpc = bitcoin.rpc.Proxy()


def check_full_rbf_optin(tx):
    """Return true if tx opts in to full-RBF"""
    for vin in tx.vin:
        if vin.nSequence < 0xFFFFFFFF-1:
            return True
    return False


tx1 = None
if args.prev_txid is not None:
    try:
        args.prev_txid = lx(args.prev_txid)
    except ValueError as err:
        parser.error('Invalid txid: %s' % str(err))

    if len(args.prev_txid) != 32:
        parser.error('Invalid txid: Wrong length.')

    tx1 = rpc.getrawtransaction(args.prev_txid)

elif not args.no_reuse:
    # Try to find an unconfirmed transaction with full-RBF enabled and a change
    # output > amount
    txids_seen = set()
    for unspent in rpc.listunspent(0,0):
        txid = unspent['outpoint'].hash
        if txid not in txids_seen:
            unspent_tx = rpc.getrawtransaction(txid)

            # FIXME: this still fails if amount doesn't leave enough for fees
            if unspent_tx.vout[0].nValue < args.amount:
                continue

            if check_full_rbf_optin(unspent_tx):
                tx1 = unspent_tx
                logging.info('Found unconfirmed full-RBF tx1 %s' % b2lx(txid))
                break

            else:
                txids_seen.add(txid)

    else:
        logging.info('No unconfirmed full-RBF tx1 found; creating new tx')


tx2 = CMutableTransaction.from_tx(tx1) if tx1 is not None else CMutableTransaction()

# There might be a better way to fund the new outputs, so delete all but the
# first input. Of course, we can't delete all the inputs - the new transaction
# wouldn't conflict with the old one and you'd pay everyone twice!
tx2.vin = tx2.vin[0:1]

if not args.first_seen_safe and len(tx2.vout) > 0:
    # Delete the change output.
    #
    # Unfortunately there isn't any way to ask Bitcoin Core if a given address
    # is a change address; if you're sending yourself funds to test the feature
    # it's not possible to distinguish change from send-to-self outputs.
    #
    # So instead we always build transactions such that the first output is
    # change, and we delete only that output. Not pretty - you don't want to do
    # something that dumb and anti-privacy in a real wallet - but without a way
    # of keeping state this is the best we've got.
    try:
        addr = CBitcoinAddress.from_scriptPubKey(tx2.vout[0].scriptPubKey)
    except ValueError:
        pass
    else:
        # There is an edge case not handled: if we have multiple outputs but
        # didn't need a change output. But whatever, this is just a demo!
        if len(tx2.vout) > 1 and rpc.validateaddress(addr)['ismine']:
            tx2.vout = tx2.vout[1:]


# Add the new output
payment_txout = CMutableTxOut(args.amount, args.address.to_scriptPubKey())
tx2.vout.append(payment_txout)

r = rpc.fundrawtransaction(tx2)
tx2 = CMutableTransaction.from_tx(r['tx'])
tx2_fee = r['fee']

# Set nSequnce on all inputs appropriately to opt-in to full-RBF
for txin in tx2.vin:
    txin.nSequence = 0

# Move change txout to 0th slot
changepos = r['changepos']
if changepos >= 0:
    tx2.vout = tx2.vout[changepos:changepos + 1] + tx2.vout[0:changepos] + tx2.vout[changepos + 1:]

else:
    # TODO: handle case where a replacement tx doesn't need a change output.
    assert tx1 is None


r = rpc.signrawtransaction(tx2)
assert(r['complete'])
tx2 = CMutableTransaction.from_tx(r['tx'])

if tx1 is not None:
    tx2_size = len(tx2.serialize())

    tx1_size = len(tx1.serialize())
    tx1_value_in = 0
    for txin in tx1.vin:
        prevout_tx = rpc.getrawtransaction(txin.prevout.hash)
        tx1_value_in += prevout_tx.vout[txin.prevout.n].nValue

    tx1_fee = tx1_value_in - sum(txout.nValue for txout in tx1.vout)

    # It's possible for fundrawtransaction to both reduce the feerate, and the
    # absolute fee. Both need to be > in tx2 than in tx1, adjust as necessary.
    if tx1_fee > tx2_fee:
        tx2.vout[0].nValue -= tx1_fee - tx2_fee
        tx2_fee = tx1_fee

    if tx1_fee / tx1_size > tx2_fee / tx2_size:
        d = int(tx1_fee * (tx2_size / tx1_size) - tx2_fee)
        tx2.vout[0].nValue -= d
        tx2_fee += d

    # Pay for the relay bandwidth consumed by the replacement.
    #
    # fundrawtransaction can't take this into account, so just calculate that delta
    # and reduce the change output by it.
    #
    # Unfortunately fundrawtransaction returns empty scriptSigs, so we have to
    # do this after signing to know how big the transaction actually is.
    relay_bw_fee = int(tx2_size/1000 * args.relay_bw_feerate*COIN)
    logging.info('Paying %s for relay bandwidth' % str_money_value(relay_bw_fee))

    # TODO: handle case where this brings nValue below the dust limit
    tx2.vout[0].nValue -= relay_bw_fee

    r = rpc.signrawtransaction(tx2)
    assert(r['complete'])
    tx2 = r['tx']

    logging.info('Old size: %.3f KB, Old fees: %s, %s BTC/KB' % \
                    (tx1_size / 1000,
                     str_money_value(tx1_fee),
                     str_money_value((tx1_fee/tx1_size) * 1000))),
    logging.info('New size: %.3f KB, New fees: %s, %s BTC/KB' % \
                    (tx2_size / 1000,
                     str_money_value(tx2_fee),
                     str_money_value((tx2_fee/tx2_size) * 1000))),


# Sanity check that tx2 replaces/conflicts with tx1
assert tx1 is None or tx1.vin[0].prevout == tx2.vin[0].prevout

if args.dryrun:
    print(b2x(tx2.serialize()))

else:
    logging.debug('Sending tx %s' % b2x(tx2.serialize()))
    txid = rpc.sendrawtransaction(tx2)
    print(b2lx(txid))