lukechilds
/
electrum
mirror of https://github.com/lukechilds/electrum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5724 Commits
21 Branches
132 Tags
52 MiB
Tree: 2be906fde2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2be906fde2'
${ noResults }
electrum/lib/coinchooser.py

116 lines
4.6 KiB
Raw Normal View History

Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2011 thomasv@gitorious
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
from collections import defaultdict, namedtuple
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
from util import NotEnoughFunds, PrintError, profiler
from transaction import Transaction
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
Bucket = namedtuple('Bucket', ['desc', 'size', 'value', 'coins'])
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
class CoinChooserBase(PrintError):
def bucketize_coins(self, coins):
keys = self.keys(coins)
buckets = defaultdict(list)
for key, coin in zip(keys, coins):
buckets[key].append(coin)
def make_Bucket(desc, coins):
size = sum(Transaction.estimated_input_size(coin)
for coin in coins)
value = sum(coin['value'] for coin in coins)
return Bucket(desc, size, value, coins)
return map(make_Bucket, buckets.keys(), buckets.values())
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
Simplify interface to make_tx in coin chooser Makes the coin chooser code simpler and easier to understand.
9 years ago
def make_tx(self, coins, outputs, change_addrs, fee_estimator,
dust_threshold):
'''Select unspent coins to spend to pay outputs. If the change is
greater than dust_threshold (after adding the change output to
the transaction) it is kept, otherwise none is sent and it is
added to the transaction fee.'''
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
output_total = sum(map(lambda x: x[2], outputs))
Track tx size directly; calculate fees from that This has several advantages. Fee calculation is now very fast, as we don&#39;t need to keep reserializing the tx. Another is that we can reason about the fees after adding a change output without having to add it, recalculate the tx fee, and remove it again.
9 years ago
# Size of the transaction with no inputs and no change
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
tx = Transaction.from_io([], outputs)
Track tx size directly; calculate fees from that This has several advantages. Fee calculation is now very fast, as we don&#39;t need to keep reserializing the tx. Another is that we can reason about the fees after adding a change output without having to add it, recalculate the tx fee, and remove it again.
9 years ago
base_size = tx.estimated_size()
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
# Returns fee given input size
fee = lambda input_size: fee_estimator(base_size + input_size)
# Collect the coins into buckets, choose a subset of the buckets
buckets = self.bucketize_coins(coins)
buckets = self.choose_buckets(buckets, output_total, fee)
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
tx.inputs = [coin for b in buckets for coin in b.coins]
input_total = sum(bucket.value for bucket in buckets)
tx_size = base_size + sum(bucket.size for bucket in buckets)
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
Track tx size directly; calculate fees from that This has several advantages. Fee calculation is now very fast, as we don&#39;t need to keep reserializing the tx. Another is that we can reason about the fees after adding a change output without having to add it, recalculate the tx fee, and remove it again.
9 years ago
# If change is above dust threshold after accounting for the
# size of the change output, add it to the transaction.
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
# Pay to bitcoin address serializes as 34 bytes
change_size = 34
fee = fee_estimator(tx_size + change_size)
change_amount = input_total - (output_total + fee)
Simplify interface to make_tx in coin chooser Makes the coin chooser code simpler and easier to understand.
9 years ago
if change_amount > dust_threshold:
Track tx size directly; calculate fees from that This has several advantages. Fee calculation is now very fast, as we don&#39;t need to keep reserializing the tx. Another is that we can reason about the fees after adding a change output without having to add it, recalculate the tx fee, and remove it again.
9 years ago
tx.outputs.append(('address', change_addrs[0], change_amount))
Simplify interface to make_tx in coin chooser Makes the coin chooser code simpler and easier to understand.
9 years ago
self.print_error('change', change_amount)
elif change_amount:
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
self.print_error('not keeping dust', change_amount)
Move debug output to end of function.
9 years ago
self.print_error("using %d inputs" % len(tx.inputs))
self.print_error("using buckets:", [bucket.desc for bucket in buckets])
Move coin choosing logic to own class This contains no change in logic, but is preparation for cleanup and possible alternative strategies.
9 years ago
return tx
Use bucketing to choose coins Bucketing is generalization of coin chooser logic that makes it easy to implement other algorithms. - Put core coin chooser functionality in base class. - Specialize derived class to implement classic electrum algorithm of oldest coins first. One bucket per output. No intended change in behaviour. Coin chooser now sorts the coins as it wants; remove redundant sorting from get_spendable_coins().
9 years ago
class CoinChooser(CoinChooserBase):
'''The original electrum algorithm. Chooses coins starting with the
oldest that are sufficient to cover the spent amount, and then
removes any not needed starting with the smallest in value.'''
def keys(self, coins):
return [coin['prevout_hash'] + ':' + str(coin['prevout_n'])
for coin in coins]
def choose_buckets(self, buckets, spent_amount, fee):
'''Spend the oldest buckets first.'''
# Unconfirmed coins are young, not old
adj_height = lambda height: 99999999 if height == 0 else height
buckets.sort(key = lambda b: max(adj_height(coin['height'])
for coin in b.coins))
selected, value, size = [], 0, 0
for bucket in buckets:
selected.append(bucket)
value += bucket.value
size += bucket.size
if value >= spent_amount + fee(size):
break
else:
raise NotEnoughFunds()
# Remove unneeded inputs starting with the smallest.
selected.sort(key = lambda b: b.value)
dropped = []
for bucket in selected:
if value - bucket.value >= spent_amount + fee(size - bucket.size):
value -= bucket.value
size -= bucket.size
dropped.append(bucket)
return [bucket for bucket in selected if bucket not in dropped]