Support symbolic amount/bid=everything which spends all funds from selected account/wallets.

lbry/wallet/account.py

@@ -7,10 +7,11 @@
 import random
 from hashlib import sha256
 from string import hexdigits
-from typing import Type, Dict, Tuple, Optional, Any, List
+from typing import Type, Dict, Tuple, Optional, Any, List, Union
 
 from lbry.error import InvalidPasswordError
 from lbry.crypto.crypt import aes_encrypt, aes_decrypt
+from lbry.wallet.dewies import amount_to_dewies
 
 from .bip32 import PrivateKey, PublicKey, KeyPath, from_extended_key_string
 from .mnemonic import Mnemonic
@@ -526,9 +527,10 @@ def get_transactions(self, **constraints):
     def get_transaction_count(self, **constraints):
         return self.ledger.get_transaction_count(wallet=self.wallet, accounts=[self], **constraints)
 
-    async def fund(self, to_account, amount=None, everything=False,
+    async def fund(self, to_account, amount: Union[int, str],
                    outputs=1, broadcast=False, **constraints):
         assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.'
+        dewies, everything = amount_to_dewies(amount)
         if everything:
             utxos = await self.get_utxos(**constraints)
             await self.ledger.reserve_outputs(utxos)
@@ -538,13 +540,13 @@ async def fund(self, to_account, amount=None, everything=False,
                 funding_accounts=[self],
                 change_account=to_account
             )
-        elif amount > 0:
+        elif dewies > 0:
             to_address = await to_account.change.get_or_create_usable_address()
             to_hash160 = to_account.ledger.address_to_hash160(to_address)
             tx = await Transaction.create(
                 inputs=[],
                 outputs=[
-                    Output.pay_pubkey_hash(amount//outputs, to_hash160)
+                    Output.pay_pubkey_hash(dewies//outputs, to_hash160)
                     for _ in range(outputs)
                 ],
                 funding_accounts=[self],

lbry/wallet/dewies.py

@@ -1,6 +1,24 @@
 import textwrap
+from typing import Tuple, Union
 from .util import coins_to_satoshis, satoshis_to_coins
 
+# Symbolic amount EVERYTHING
+AMOUNT_EVERYTHING = "EVERYTHING"
+
+def amount_is_everything(amount: Union[int, str]) -> bool:
+    if isinstance(amount, str):
+        if amount != AMOUNT_EVERYTHING:
+            raise ValueError(f"The value '{amount}' for argument 'amount' is invalid.")
+        return True
+    elif isinstance(amount, int):
+        return False
+    else:
+        raise ValueError(f"The value '{amount}' for argument 'amount' is invalid.")
+
+def amount_to_dewies(amount: Union[int, str]) -> Tuple[int, bool]:
+    everything = amount_is_everything(amount)
+    dewies = 0 if everything else amount
+    return dewies, everything
 
 def lbc_to_dewies(lbc: str) -> int:
     try:

lbry/wallet/ledger.py

@@ -956,7 +956,10 @@ async def _reset_balance_cache(self, e: TransactionEvent):
 
     @staticmethod
     def constraint_spending_utxos(constraints):
-        constraints['txo_type__in'] = (0, TXO_TYPES['purchase'])
+        spending_types = {TXO_TYPES['other'], TXO_TYPES['purchase']}
+        if 'txo_type__in' in constraints:
+            spending_types &= constraints['txo_type__in']
+        constraints['txo_type__in'] = spending_types
 
     async def get_purchases(self, resolve=False, **constraints):
         purchases = await self.db.get_purchases(**constraints)

lbry/wallet/transaction.py

@@ -2,7 +2,7 @@
 import logging
 import typing
 from binascii import hexlify, unhexlify
-from typing import List, Iterable, Optional, Tuple
+from typing import List, Iterable, Optional, Tuple, Union
 
 from lbry.error import InsufficientFundsError
 from lbry.crypto.hash import hash160, sha256
@@ -12,9 +12,10 @@
 from lbry.schema.base import Signable
 from lbry.schema.purchase import Purchase
 from lbry.schema.support import Support
+from lbry.wallet.dewies import amount_to_dewies
 
 from .script import InputScript, OutputScript
-from .constants import COIN, DUST, NULL_HASH32
+from .constants import COIN, DUST, NULL_HASH32, TXO_TYPES
 from .bcd_data_stream import BCDataStream
 from .hash import TXRef, TXRefImmutable
 from .util import ReadOnlyList
@@ -793,7 +794,8 @@ def ensure_all_have_same_ledger_and_wallet(
     @classmethod
     async def create(cls, inputs: Iterable[Input], outputs: Iterable[Output],
                      funding_accounts: Iterable['Account'], change_account: 'Account',
-                     sign: bool = True):
+                     sign: bool = True,
+                     *, everything: bool = False):
         """ Find optimal set of inputs when only outputs are provided; add change
             outputs if only inputs are provided or if inputs are greater than outputs. """
 
@@ -803,6 +805,20 @@ async def create(cls, inputs: Iterable[Input], outputs: Iterable[Output],
 
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
 
+        if everything and not any(map(lambda txi: not txi.txo_ref.txo.is_claim, tx._inputs)):
+            # Spend "everything" requested, but inputs not specified.
+            # Make a set of inputs from all funding accounts.
+            all_utxos = []
+            for acct in funding_accounts:
+                constraints = {'txo_type__in': {TXO_TYPES['other']}}
+                utxos = await acct.get_utxos(**constraints)
+                await acct.ledger.reserve_outputs(utxos)
+                all_utxos.extend(utxos)
+            if not all_utxos:
+                raise InsufficientFundsError()
+            everything_in = [Input.spend(txo) for txo in all_utxos]
+            tx.add_inputs(everything_in)
+
         # value of the outputs plus associated fees
         cost = (
             tx.get_base_fee(ledger) +
@@ -811,6 +827,17 @@ async def create(cls, inputs: Iterable[Input], outputs: Iterable[Output],
         # value of the inputs less the cost to spend those inputs
         payment = tx.get_effective_input_sum(ledger)
 
+        if everything and tx._outputs and payment > cost:
+            # Distribute the surplus across the known set of outputs.
+            amount = (payment - cost) // len(tx._outputs)
+            for txo in tx._outputs:
+                txo.amount += amount
+            # Recompute: value of the outputs plus associated fees
+            cost = (
+                    tx.get_base_fee(ledger) +
+                    tx.get_total_output_sum(ledger)
+            )
+
         try:
 
             for _ in range(5):
@@ -889,65 +916,89 @@ async def sign(self, funding_accounts: Iterable['Account'], extra_keys: dict = N
         self._reset()
 
     @classmethod
-    def pay(cls, amount: int, address: bytes, funding_accounts: List['Account'], change_account: 'Account'):
+    def pay(cls, amount: Union[int, str], addresses: List[bytes],
+            funding_accounts: List['Account'], change_account: 'Account'):
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
-        output = Output.pay_pubkey_hash(amount, ledger.address_to_hash160(address))
-        return cls.create([], [output], funding_accounts, change_account)
+        dewies, everything = amount_to_dewies(amount)
+        outputs = []
+        for address in addresses:
+            if ledger.is_pubkey_address(address):
+                outputs.append(
+                    Output.pay_pubkey_hash(
+                        dewies, ledger.address_to_hash160(address)
+                    )
+                )
+            elif ledger.is_script_address(address):
+                outputs.append(
+                    Output.pay_script_hash(
+                        dewies, ledger.address_to_hash160(address)
+                    )
+                )
+            else:
+                raise ValueError(f"Unsupported address: '{address}'")  # TODO: use error from lbry.error
+        return cls.create([], outputs, funding_accounts, change_account, everything=everything)
 
     @classmethod
     def claim_create(
-            cls, name: str, claim: Claim, amount: int, holding_address: str,
+            cls, name: str, claim: Claim, amount: Union[int, str], holding_address: str,
             funding_accounts: List['Account'], change_account: 'Account', signing_channel: Output = None):
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
+        dewies, everything = amount_to_dewies(amount)
         claim_output = Output.pay_claim_name_pubkey_hash(
-            amount, name, claim, ledger.address_to_hash160(holding_address)
+            dewies, name, claim, ledger.address_to_hash160(holding_address)
         )
         if signing_channel is not None:
             claim_output.sign(signing_channel, b'placeholder txid:nout')
-        return cls.create([], [claim_output], funding_accounts, change_account, sign=False)
+        return cls.create([], [claim_output], funding_accounts, change_account,
+                          sign=False, everything=everything)
 
     @classmethod
     def claim_update(
-            cls, previous_claim: Output, claim: Claim, amount: int, holding_address: str,
+            cls, previous_claim: Output, claim: Claim, amount: Union[int, str], holding_address: str,
             funding_accounts: List['Account'], change_account: 'Account', signing_channel: Output = None):
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
+        dewies, everything = amount_to_dewies(amount)
         updated_claim = Output.pay_update_claim_pubkey_hash(
-            amount, previous_claim.claim_name, previous_claim.claim_id,
+            dewies, previous_claim.claim_name, previous_claim.claim_id,
             claim, ledger.address_to_hash160(holding_address)
         )
         if signing_channel is not None:
             updated_claim.sign(signing_channel, b'placeholder txid:nout')
         else:
             updated_claim.clear_signature()
         return cls.create(
-            [Input.spend(previous_claim)], [updated_claim], funding_accounts, change_account, sign=False
+            [Input.spend(previous_claim)], [updated_claim], funding_accounts, change_account,
+            sign=False, everything=everything
         )
 
     @classmethod
-    def support(cls, claim_name: str, claim_id: str, amount: int, holding_address: str,
+    def support(cls, claim_name: str, claim_id: str, amount: Union[int, str], holding_address: str,
                 funding_accounts: List['Account'], change_account: 'Account', signing_channel: Output = None,
                 comment: str = None):
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
+        dewies, everything = amount_to_dewies(amount)
         if signing_channel is not None or comment is not None:
             support = Support()
             if comment is not None:
                 support.comment = comment
             support_output = Output.pay_support_data_pubkey_hash(
-                amount, claim_name, claim_id, support, ledger.address_to_hash160(holding_address)
+                dewies, claim_name, claim_id, support, ledger.address_to_hash160(holding_address)
             )
             if signing_channel is not None:
                 support_output.sign(signing_channel, b'placeholder txid:nout')
         else:
             support_output = Output.pay_support_pubkey_hash(
-                amount, claim_name, claim_id, ledger.address_to_hash160(holding_address)
+                dewies, claim_name, claim_id, ledger.address_to_hash160(holding_address)
             )
-        return cls.create([], [support_output], funding_accounts, change_account, sign=False)
+        return cls.create([], [support_output], funding_accounts, change_account,
+                          sign=False, everything=everything)
 
     @classmethod
     def purchase(cls, claim_id: str, amount: int, merchant_address: bytes,
                  funding_accounts: List['Account'], change_account: 'Account'):
         ledger, _ = cls.ensure_all_have_same_ledger_and_wallet(funding_accounts, change_account)
-        payment = Output.pay_pubkey_hash(amount, ledger.address_to_hash160(merchant_address))
+        dewies, _ = amount_to_dewies(amount)
+        payment = Output.pay_pubkey_hash(dewies, ledger.address_to_hash160(merchant_address))
         data = Output.add_purchase_data(Purchase(claim_id))
         return cls.create([], [payment, data], funding_accounts, change_account)
 

tests/integration/claims/test_claim_commands.py

@@ -1125,23 +1125,31 @@ async def test_channel_bids(self):
         tx = await self.channel_update(claim_id)
         self.assertEqual(tx['outputs'][0]['amount'], '5.0')
 
-        # bid changed on update
+        # spend exactly amount available, no change
+        tx = await self.channel_update(claim_id, bid_everything=True)
+        await self.assertBalance(self.account, '0.0')
+        self.assertEqual(len(tx['outputs']), 1)  # no change
+        self.assertEqual(tx['outputs'][0]['amount'], '9.991457')
+        self.assertItemCount(await self.daemon.jsonrpc_channel_list(), 1)
+
+        # bid reduced on update
         tx = await self.channel_update(claim_id, bid='4.0')
         self.assertEqual(tx['outputs'][0]['amount'], '4.0')
 
-        await self.assertBalance(self.account, '5.991503')
+        await self.assertBalance(self.account, '5.991299')
 
         # not enough funds
         with self.assertRaisesRegex(
                 InsufficientFundsError, "Not enough funds to cover this transaction."):
             await self.channel_create('@foo2', '9.0')
         self.assertItemCount(await self.daemon.jsonrpc_channel_list(), 1)
-        await self.assertBalance(self.account, '5.991503')
+        await self.assertBalance(self.account, '5.991299')
 
         # spend exactly amount available, no change
-        tx = await self.channel_create('@foo3', '5.981322')
+        tx = await self.channel_create('@foo3', bid=None, bid_everything=True)
         await self.assertBalance(self.account, '0.0')
         self.assertEqual(len(tx['outputs']), 1)  # no change
+        self.assertEqual(tx['outputs'][0]['amount'], '5.98122')
         self.assertItemCount(await self.daemon.jsonrpc_channel_list(), 2)
 
     async def test_setting_channel_fields(self):
@@ -1337,23 +1345,31 @@ async def test_stream_bids(self):
         tx = await self.stream_update(claim_id)
         self.assertEqual(tx['outputs'][0]['amount'], '2.0')
 
-        # bid changed on update
+        # spend exactly amount available, no change
+        tx = await self.stream_update(claim_id, bid_everything=True)
+        await self.assertBalance(self.account, '0.0')
+        self.assertEqual(len(tx['outputs']), 1)  # no change
+        self.assertEqual(tx['outputs'][0]['amount'], '9.993347')
+        self.assertItemCount(await self.daemon.jsonrpc_claim_list(), 1)
+
+        # bid reduced on update
         tx = await self.stream_update(claim_id, bid='3.0')
         self.assertEqual(tx['outputs'][0]['amount'], '3.0')
 
-        await self.assertBalance(self.account, '6.993319')
+        await self.assertBalance(self.account, '6.993134')
 
         # not enough funds
         with self.assertRaisesRegex(
                 InsufficientFundsError, "Not enough funds to cover this transaction."):
             await self.stream_create('foo2', '9.0')
         self.assertItemCount(await self.daemon.jsonrpc_claim_list(), 1)
-        await self.assertBalance(self.account, '6.993319')
+        await self.assertBalance(self.account, '6.993134')
 
         # spend exactly amount available, no change
-        tx = await self.stream_create('foo3', '6.98523')
+        tx = await self.stream_create('foo3', bid=None, bid_everything=True)
         await self.assertBalance(self.account, '0.0')
         self.assertEqual(len(tx['outputs']), 1)  # no change
+        self.assertEqual(tx['outputs'][0]['amount'], '6.985055')
         self.assertItemCount(await self.daemon.jsonrpc_claim_list(), 2)
 
     async def test_stream_update_and_abandon_across_accounts(self):
@@ -2113,7 +2129,7 @@ async def test_abandoning_stream_at_loss(self):
     async def test_publish(self):
 
         # errors on missing arguments to create a stream
-        with self.assertRaisesRegex(Exception, "'bid' is a required argument for new publishes."):
+        with self.assertRaisesRegex(Exception, "None or null is not valid value for argument 'bid'."):
             await self.daemon.jsonrpc_publish('foo')
 
         # successfully create stream
@@ -2271,9 +2287,32 @@ async def test_regular_supports_and_tip_supports(self):
         self.assertEqual(txs2[0]['value'], '0.0')
         self.assertEqual(txs2[0]['fee'], '-0.0001415')
 
+        # send all remaining funds to support the claim using account2
+        support = await self.out(
+            self.daemon.jsonrpc_support_create(
+                claim_id, amount=None, tip=False, account_id=account2.id, wallet_id='wallet2',
+                funding_account_ids=[account2.id], amount_everything=True, blocking=True)
+        )
+        await self.confirm_tx(support['txid'])
+
+        # account2 balance went down to 0.0
+        await self.assertBalance(self.account, '3.979769')
+        await self.assertBalance(account2,     '0.0')
+
+        # verify that the outgoing support is marked correctly as is_tip=False in account2
+        txs2 = await self.transaction_list(wallet_id='wallet2')
+        self.assertEqual(len(txs2[0]['support_info']), 1)
+        self.assertEqual(txs2[0]['support_info'][0]['balance_delta'], '-1.9996035')
+        self.assertEqual(txs2[0]['support_info'][0]['claim_id'], claim_id)
+        self.assertFalse(txs2[0]['support_info'][0]['is_tip'])
+        self.assertFalse(txs2[0]['support_info'][0]['is_spent'])
+        self.assertEqual(txs2[0]['value'], '0.0')
+        self.assertEqual(txs2[0]['fee'], '-0.0001135')
+
         # abandoning the tip increases balance and shows tip as spent
         await self.support_abandon(claim_id)
         await self.assertBalance(self.account, '4.979662')
+        await self.assertBalance(account2,     '0.0')
         txs = await self.transaction_list(account_id=self.account.id)
         self.assertEqual(len(txs[0]['abandon_info']), 1)
         self.assertEqual(len(txs[1]['support_info']), 1)