mirror of
https://github.com/Chia-Network/chia-blockchain.git
synced 2024-09-20 16:08:51 +03:00
7e3e18bdfd
* Resend transactions (#11167) * Resend transactions * Don't recheck transactions more frequently than timeout * Add wallet resend parameter to config, move timeout code out of tx store, but close to call site * Add a test for wallet transaction resend * Add test for wallet retry * isort new files for precommit and update workflows * Use correct fixture name * LGTM - remove unused import Co-authored-by: Earle Lowe <e.lowe@chia.net> * less except -> false (#10219) * less except -> false * establish_connection() and .perform_handshake() can just return None * remove more pointless, and no wrong, assertions * Write python version error to stderr (#11239) Co-authored-by: wjblanke <wjb98672@gmail.com> * simplify SizedBytes and StructStream (#11429) * simplify SizedBytes and StructStream * lint * super() !!! * do not pass parameter up to super().__init__() * Update chia/util/struct_stream.py Co-authored-by: Arvid Norberg <arvid@libtorrent.org> * parse fixed-width int data from class name * add int512 and uint128 .from_bytes(), test .parse() failures * test serialization against struct.pack() * use typing_extensions for final * override ignore * stop using struct for StructStream oh the irony * fixup .to_bytes() to accept parameters again for where we use that * bring back signed parameter * format * adjust tests for new exception * eliminate custom coding for uint128 and int512 * tidy * remove unused StructStream.PACK attribute * add direct tests for parse_metadata_from_name() * stricter hinting * remove no-longer-needed typeshed work-around * apply strict type checking to all touched files * remove StructStream override of .to_bytes() * tidy * types touchup * add unused parameter comments Co-authored-by: Arvid Norberg <arvid@libtorrent.org> Co-authored-by: wjblanke <wjb98672@gmail.com> * Allow services to set a non-default max request body size limit (#11516) * updated bls to 13 (#11529) * reduce the redundant computations of coin_ids in block_body_validation (#11530) * add test for streamable -> json conversion (#11527) * add test for streamable -> json conversion * fixup test * Uses the new `from_bytes_unchecked` method in blspy, to improve perfo… (#11463) * Uses the new `from_bytes_unchecked` method in blspy, to improve performance * Update test * Fix merge conflict * Use from_bytes_unchecked in post_init and from_json * More uniform code * rename test files that are missing test_ prefix (#10712) * rename test files that are missing test_ prefix * update mypy and isort excludes * skip test_get_host_addr6() in GitHub Actions under macOS * rebuild workflows * Coin Selection Refactor With CAT Coin Selection Refactor (#9975) * add exact match and best exact match algorithms * optimize algorithm further this might be good. * lint * fix bad logic * add final algorithms * delete lint * oops * Update coin_selection.py * simplify and fix knapsack algoritm * simplify code and correct logic * make it way better. * clarify comments and check for edge cases. * add comments and stuff * improve coin selection addressed comments Thanks! * add coin_selection rpc tests. * clean up and add new unit tests * undo test changes * add extra test cases * move coin_selection to its own function and switch to it for cat and main wallet. * add cat tests * lint * make function align with standards also removed test * make test better * add proper types * Improve code clarity * wallet: fix coin selection bugs * wallet: add an assert just in case * tests: add some sleeps to reduce flakiness * Isort Co-authored-by: Kyle Altendorf <sda@fstab.net> * fix bad merge * lint * fix tests * address aforementioned changes. * remove wallet test * isort * more tests and fixes * lint * rename to amount for coin selection rpc * fix incase we have no smaller coins * fix tests + lint * re add asserts * oops missed me. * lint * fix test * Squashed commit of the following: commit34a2235de5
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Apr 13 10:09:42 2022 -0400 clarify comment commitadbf7f4f94
Author: Jack Nelson <jack@jacknelson.xyz> Date: Tue Apr 12 20:27:05 2022 -0400 linty lint commit5ebc1ac9fd
Author: Jack Nelson <jack@jacknelson.xyz> Date: Tue Apr 12 20:17:19 2022 -0400 add failure test and final changes commit7e5a21b4c2
Author: Jack Nelson <jack@jacknelson.xyz> Date: Tue Apr 12 19:35:18 2022 -0400 add descriptions and slim down code commit31c95b916d
Merge:d7b91295b
d9b0ef5f3
Author: Jack Nelson <jack@jacknelson.xyz> Date: Mon Apr 11 10:12:05 2022 -0400 Merge branch 'jack-cat-coinselection' into jn_coinselection_dust commitd7b91295b5
Author: Jack Nelson <jack@jacknelson.xyz> Date: Sun Apr 10 20:31:09 2022 -0400 lint commit30dc7c0ab4
Author: Jack Nelson <jack@jacknelson.xyz> Date: Sun Apr 10 20:25:52 2022 -0400 fix tests commit6c8c2e4874
Author: Jack Nelson <jack@jacknelson.xyz> Date: Thu Mar 31 15:06:00 2022 -0400 remove duplicate code. commit9f79b6f304
Author: Jack Nelson <jack@jacknelson.xyz> Date: Thu Mar 31 15:01:10 2022 -0400 address more concerns commit67c1b3929f
Author: Jack Nelson <jack@jacknelson.xyz> Date: Thu Mar 31 12:59:05 2022 -0400 fix logic error commit2d19a53245
Author: Jack Nelson <jack@jacknelson.xyz> Date: Thu Mar 31 11:47:52 2022 -0400 simplify and de duplicate code commit6ab1cc79bb
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 21:34:50 2022 -0400 add function and select individual coin commit582c17aa8d
Merge:ce2165942
618fbaeba
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 21:14:37 2022 -0400 Merge branch 'jack-cat-coinselection' into jn_coinselection_dust commitce21659429
Merge:16aabb3fd
6daba28db
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 20:53:21 2022 -0400 Merge branch 'jack-cat-coinselection' into jn_coinselection_dust commit16aabb3fd5
Merge:0b9fc2845
2286fe426
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 20:49:02 2022 -0400 Merge branch 'jack-cat-coinselection' into jn_coinselection_dust commit0b9fc28455
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 20:38:12 2022 -0400 lint commit62e74c72f4
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 20:34:22 2022 -0400 fix logic and tests commite738f44320
Author: Jack Nelson <jack@jacknelson.xyz> Date: Wed Mar 30 18:52:05 2022 -0400 deal with dust and add tests * make sure that we do not use any dust * minor change * address concerns * adjust comments * adjust comment Co-authored-by: Mariano Sorgente <sorgente711@gmail.com> Co-authored-by: Kyle Altendorf <sda@fstab.net> * rebuild workflows (#11543) * remove the cache from CoinStore. It appears the cost of maintaining the cache outweighs the gains. (#11540) * Keep daemon websocket alive during keyring unlock (#11371) * When prompting to unlock the keyring during daemon launch, it's possible that the daemon websocket connection will timeout before the user has entered their passphrase. We can't quickly detect that the connection has timed-out, so instead we now reconnect after collecting the passphrase, unlock the keyring, and then close the old connection. * mypy fix * Switch to using asyncio.loop.run_in_executor to collect the passphrase on its own thread. * Use a new ThreadPoolExecutor configured with 1 worker thread. * Support searching derived addresses on testnet. (#11449) * Support searching derived addresses on testnet. * Added tests * Optimize code to not perform useless subgroup checks (#11546) * Optimize code to not perform useless subgroup checks * Revert less important optimizations * hints and strict type checking for test_wallet (#11541) * hints and strict type checking for test_wallet * fixup * flip flop * disable pytest-monitor by default (#11507) * disable pytest-monitor by default * take 2 * make recurse_jsonify() work directly on types (#11537) * make recurse_jsonify() work directly on types, circumventing the dataclasses.asdict() step. This enables simpler integration of non dataclasses into the Streamable and JSON protocols * add benchmark for Streamable.to_json_dict() * tests: Split up and improve `test_wallet_rpc.py` (#11552) This breaks up the one big test into ``` test_send_transaction test_create_signed_transaction test_create_signed_transaction_with_coin_announcement test_create_signed_transaction_with_puzzle_announcement test_send_transaction_multi test_get_transactions test_get_transaction_count test_cat_endpoints test_offer_endpoints test_key_and_address_endpoints ``` Note that there is still much more room for improvements. Also the following tests can still be split up more: ``` test_get_transactions test_cat_endpoints test_offer_endpoints test_key_and_address_endpoints ``` * Remove unneeded uint64() intermediate in CAT wallet (#11575) * Get get_args() and get_origin() from typing_extensions (#11571) * Get get_args() and get_origin() from typing_extensions * Update streamable.py * cleanup * Fix several flaky tests (#11576) * Increase some of the timeouts to reduce flakiness * Experiment with CI for flakiness * Force more runs * Add argument name * Fix flaky mempool test * Attempt to fix another flaky test * Fix wallet retry test * Missing arg * Lint * Increase benchmark test time * Debug * Debug * Simplify retry test * Lint * More lint * Return false instead of assert * No need to check disconnect twice (since we don't break, this was flaky) * Remove useless changes * Accidental changes revert * Accidental changes revert 2 * Accidental changes revert 3 * Revert fixture * Fix a few additional flaky tests (#11597) * Fix a few additional flaky tests * Lint * Update tests/core/full_node/stores/test_full_node_store.py Co-authored-by: Jeff <jeff@chia.net> * Fix merge conflict * Remove unnecessary function Co-authored-by: Jeff <jeff@chia.net> * Bind port 0 to fix race condition when grabbing available ports (#11578) * port 0 to fix flakiness * Try fixing setup_full_system * Try fixing setup_full_system, and lint * More attempts to fix * No more calls to get random ports in setup_nodes * Revert accidental changes * Timelord extra arg * Try with port 0 * Fix daemon test, and lint * Try without 0.0.0.0 * Back to 0.0.0.0 * Try a few timelord changes to get test running * Increase timeout again * Use the correct interface to get the port * INFO logging to debug issue * Revert "INFO logging to debug issue" This reverts commit7c379e5cca
. * Fix advertised port log * Add extra log * Logging back * Rollback the timelord changes * Try port 0 timelord * Revert "Try port 0 timelord" This reverts commit4997faf3b2
. * Try full green, change ordering * Remove unused var * speed up simulation and cleanup * Now try without the port config * Fix a flaky call to get_event_loop * Try getting the port dynamically * No dynamic port * Try changing the ordering * Try adding a sleep * Back to what works * Timelord before vdf clients * Dynamic port for 1st timelord * Revert "Dynamic port for 1st timelord" This reverts commit0f322a15b7
. * Revert "Timelord before vdf clients" This reverts commit3286c34696
. * Revert "Back to what works" This reverts commit30380dffb7
. * Revert "Try adding a sleep" This reverts commit9212b665a6
. * Revert "Try changing the ordering" This reverts commita62597d70d
. * Revert "No dynamic port" This reverts commit5d2e15749b
. * Revert "Try getting the port dynamically" This reverts commitef9cd75679
. * Revert "Fix a flaky call to get_event_loop" This reverts commit01a000fdfb
. * Try one to 0 * Just not 0 * Don't get port dynamically * Cleanup a bit * Fix * Some cleanup work * Some cleanup work * Fix daemon test * Cleanup * Remove arguments * restore missing hints being stored as None (instead of 0-length bytes) (#11568) * Coin simplification (#11567) * factor out as_list() from Coin into free function. Remove unused name_str() from Coin. Minor optimization of hash_coin_ids() for common case. * extend Coin unit test * test installer on fedora:36, drop 33 * add tests.util.misc.assert_maximum_duration for benchmark assertions (#11589) * add tests.util.misc.assert_maximum_duration for benchmark assertions * fix some imports * more * lint * correct duration * hint fixup * rename to caller_file_and_line() * set default timer to thread_time() * extract gc manager and default to disabling * self calibrate overhead * wrap none-ness behind .results() method * add messages * from __future__ import annotations * yield out self * final from typing_extensions * split it * just use Future * tweak * tweak * correction in loosely hint checked file * all future indexing in hints * union for the hints * rename * assert_runtime() * another rename... * message -> label * label all results with test names * oops * early return from _set_spent function (#11594) * check for removals before calling function * move condition to function * remove redundant condition (#11582) * fix built-in profiler to work for mac (#11590) * Bump actions/setup-python from 2 to 3 (#10949) * Bump actions/setup-python from 2 to 3 Bumps [actions/setup-python](https://github.com/actions/setup-python) from 2 to 3. - [Release notes](https://github.com/actions/setup-python/releases) - [Commits](https://github.com/actions/setup-python/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/setup-python dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> * Fixup templates for python@v3 Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Gene Hoffman <hoffmang@hoffmang.com> * avoid cancelling release/** and long_lived/** (#11519) * tests: Some adjustments in `test_offer_endpoints` (#11558) This is a follow up after #11552 which basically used the initial parts of `test_cat_endpoints` to make `test_offer_endpoints` working. Now this PR drops a lot of the stuff we can assume to be not needed in this test because its tested in `test_cat_endpoints` and it adds some general improvments to it. * async sleep and require connection reset error for DoS test (#11612) * fix jsonify bool * Remove is not None and length assertion in select_coins() (#11569) * Remove is not None and length assertion in select_coins() The `coins is not None` check seems unneeded since `select_coins()` is hinted to return `Set[Coin]`. The length requirement needlessly restricts from being able to request a zero amount. Either situation would either trigger an exception in the next assert, or trigger the assert itself for non-zero amounts requested. * also remove from cat_wallet.py * new port 0 stuff Co-authored-by: Adam Kelly <338792+aqk@users.noreply.github.com> Co-authored-by: Earle Lowe <e.lowe@chia.net> Co-authored-by: Evan Graham <me@luakt.net> Co-authored-by: wjblanke <wjb98672@gmail.com> Co-authored-by: Arvid Norberg <arvid@libtorrent.org> Co-authored-by: Mariano Sorgente <3069354+mariano54@users.noreply.github.com> Co-authored-by: Jack Nelson <jack@jacknelson.xyz> Co-authored-by: Mariano Sorgente <sorgente711@gmail.com> Co-authored-by: Jeff <jeff@chia.net> Co-authored-by: dustinface <35775977+xdustinface@users.noreply.github.com> Co-authored-by: neurosis69 <83925572+neurosis69@users.noreply.github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Gene Hoffman <hoffmang@hoffmang.com> Co-authored-by: William Allen <wallentx@users.noreply.github.com>
291 lines
12 KiB
Python
291 lines
12 KiB
Python
import logging
|
|
from random import randrange
|
|
from typing import List, Set
|
|
|
|
import pytest
|
|
|
|
from chia.consensus.default_constants import DEFAULT_CONSTANTS
|
|
from chia.types.blockchain_format.coin import Coin
|
|
from chia.types.blockchain_format.sized_bytes import bytes32
|
|
from chia.util.hash import std_hash
|
|
from chia.util.ints import uint32, uint64, uint128
|
|
from chia.wallet.coin_selection import check_for_exact_match, knapsack_coin_algorithm, select_coins
|
|
from chia.wallet.util.wallet_types import WalletType
|
|
from chia.wallet.wallet_coin_record import WalletCoinRecord
|
|
|
|
|
|
class TestCoinSelection:
|
|
@pytest.fixture(scope="function")
|
|
def a_hash(self) -> bytes32:
|
|
return std_hash(b"a")
|
|
|
|
def test_exact_match(self, a_hash: bytes32) -> None:
|
|
coin_list = [
|
|
Coin(a_hash, a_hash, uint64(220000)),
|
|
Coin(a_hash, a_hash, uint64(120000)),
|
|
Coin(a_hash, a_hash, uint64(22)),
|
|
]
|
|
assert check_for_exact_match(coin_list, uint64(220000)) == coin_list[0]
|
|
assert check_for_exact_match(coin_list, uint64(22)) == coin_list[2]
|
|
# check for no match.
|
|
assert check_for_exact_match(coin_list, uint64(20)) is None
|
|
|
|
def test_knapsack_coin_selection(self, a_hash: bytes32) -> None:
|
|
tries = 100
|
|
coins_to_append = 1000
|
|
amounts = list(range(1, coins_to_append))
|
|
amounts.sort(reverse=True)
|
|
coin_list: List[Coin] = [Coin(a_hash, a_hash, uint64(100000000 * a)) for a in amounts]
|
|
for i in range(tries):
|
|
knapsack = knapsack_coin_algorithm(coin_list, uint128(30000000000000), DEFAULT_CONSTANTS.MAX_COIN_AMOUNT)
|
|
assert knapsack is not None
|
|
assert sum([coin.amount for coin in knapsack]) >= 310000000
|
|
|
|
def test_knapsack_coin_selection_2(self, a_hash: bytes32) -> None:
|
|
coin_amounts = [6, 20, 40, 80, 150, 160, 203, 202, 201, 320]
|
|
coin_amounts.sort(reverse=True)
|
|
coin_list: List[Coin] = [Coin(a_hash, a_hash, uint64(a)) for a in coin_amounts]
|
|
# coin_list = set([coin for a in coin_amounts])
|
|
for i in range(100):
|
|
knapsack = knapsack_coin_algorithm(coin_list, uint128(265), DEFAULT_CONSTANTS.MAX_COIN_AMOUNT)
|
|
assert knapsack is not None
|
|
selected_sum = sum(coin.amount for coin in list(knapsack))
|
|
assert 265 <= selected_sum <= 280 # Selects a set of coins which does exceed by too much
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_coin_selection_randomly(self, a_hash: bytes32) -> None:
|
|
coin_base_amounts = [3, 6, 20, 40, 80, 150, 160, 203, 202, 201, 320]
|
|
coin_amounts = []
|
|
spendable_amount = 0
|
|
# this is possibly overkill, but it's a good test.
|
|
for i in range(3000):
|
|
for amount in coin_base_amounts:
|
|
c_amount = randrange(1, 10000000) * amount
|
|
coin_amounts.append(c_amount)
|
|
spendable_amount += c_amount
|
|
spendable_amount = uint128(spendable_amount)
|
|
|
|
coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(Coin(a_hash, a_hash, uint64(a)), uint32(1), uint32(1), False, True, WalletType(0), 1)
|
|
for a in coin_amounts
|
|
]
|
|
for target_amount in coin_amounts[:100]: # select the first 100 values
|
|
result: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
uint128(target_amount),
|
|
)
|
|
assert result is not None
|
|
assert sum([coin.amount for coin in result]) >= target_amount
|
|
assert len(result) <= 500
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_coin_selection_with_dust(self, a_hash: bytes32) -> None:
|
|
spendable_amount = uint128(5000000000000 + 10000)
|
|
coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(
|
|
Coin(a_hash, a_hash, uint64(5000000000000)), uint32(1), uint32(1), False, True, WalletType(0), 1
|
|
)
|
|
]
|
|
for i in range(10000):
|
|
coin_list.append(
|
|
WalletCoinRecord(
|
|
Coin(a_hash, std_hash(i), uint64(1)), uint32(1), uint32(1), False, True, WalletType(0), 1
|
|
)
|
|
)
|
|
# make sure coins are not identical.
|
|
for target_amount in [10000, 9999]:
|
|
result: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
uint128(target_amount),
|
|
)
|
|
assert result is not None
|
|
assert sum([coin.amount for coin in result]) >= target_amount
|
|
assert len(result) == 1 # only one coin should be selected
|
|
|
|
for i in range(100):
|
|
coin_list.append(
|
|
WalletCoinRecord(
|
|
Coin(a_hash, std_hash(i), uint64(2000)), uint32(1), uint32(1), False, True, WalletType(0), 1
|
|
)
|
|
)
|
|
spendable_amount = uint128(spendable_amount + 2000 * 100)
|
|
for target_amount in [50000, 25000, 15000, 10000, 9000, 3000]: # select the first 100 values
|
|
dusty_result: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
uint128(target_amount),
|
|
)
|
|
assert dusty_result is not None
|
|
assert sum([coin.amount for coin in dusty_result]) >= target_amount
|
|
for coin in dusty_result:
|
|
assert coin.amount > 1
|
|
assert len(dusty_result) <= 500
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_coin_selection_failure(self, a_hash: bytes32) -> None:
|
|
spendable_amount = uint128(10000)
|
|
coin_list: List[WalletCoinRecord] = []
|
|
for i in range(10000):
|
|
coin_list.append(
|
|
WalletCoinRecord(
|
|
Coin(a_hash, std_hash(i), uint64(1)), uint32(1), uint32(1), False, True, WalletType(0), 1
|
|
)
|
|
)
|
|
# make sure coins are not identical.
|
|
# test for failure
|
|
with pytest.raises(ValueError):
|
|
for target_amount in [10000, 9999]:
|
|
await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
uint128(target_amount),
|
|
)
|
|
# test not enough coin failure.
|
|
with pytest.raises(ValueError):
|
|
for target_amount in [10001, 20000]:
|
|
await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
uint128(target_amount),
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_coin_selection(self, a_hash: bytes32) -> None:
|
|
coin_amounts = [3, 6, 20, 40, 80, 150, 160, 203, 202, 201, 320]
|
|
coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(Coin(a_hash, a_hash, uint64(a)), uint32(1), uint32(1), False, True, WalletType(0), 1)
|
|
for a in coin_amounts
|
|
]
|
|
spendable_amount = uint128(sum(coin_amounts))
|
|
|
|
# check for exact match
|
|
target_amount = uint128(40)
|
|
exact_match_result: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert exact_match_result is not None
|
|
assert sum([coin.amount for coin in exact_match_result]) >= target_amount
|
|
assert len(exact_match_result) == 1
|
|
|
|
# check for match of 2
|
|
target_amount = uint128(153)
|
|
match_2: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert match_2 is not None
|
|
assert sum([coin.amount for coin in match_2]) == target_amount
|
|
assert len(match_2) == 2
|
|
# check for match of at least 3. it is random after all.
|
|
target_amount = uint128(541)
|
|
match_3: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert match_3 is not None
|
|
assert sum([coin.amount for coin in match_3]) >= target_amount
|
|
assert len(match_3) >= 3
|
|
|
|
# check for match of all
|
|
target_amount = spendable_amount
|
|
match_all: Set[Coin] = await select_coins(
|
|
spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert match_all is not None
|
|
assert sum([coin.amount for coin in match_all]) == target_amount
|
|
assert len(match_all) == len(coin_list)
|
|
|
|
# test smallest greater than target
|
|
greater_coin_amounts = [1, 2, 5, 20, 400, 700]
|
|
greater_coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(Coin(a_hash, a_hash, uint64(a)), uint32(1), uint32(1), False, True, WalletType(0), 1)
|
|
for a in greater_coin_amounts
|
|
]
|
|
greater_spendable_amount = uint128(sum(greater_coin_amounts))
|
|
target_amount = uint128(625)
|
|
smallest_result: Set[Coin] = await select_coins(
|
|
greater_spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
greater_coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert smallest_result is not None
|
|
assert sum([coin.amount for coin in smallest_result]) > target_amount
|
|
assert len(smallest_result) == 1
|
|
|
|
# test smallest greater than target with only 1 large coin.
|
|
single_greater_coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(Coin(a_hash, a_hash, uint64(70000)), uint32(1), uint32(1), False, True, WalletType(0), 1)
|
|
]
|
|
single_greater_spendable_amount = uint128(70000)
|
|
target_amount = uint128(50000)
|
|
single_greater_result: Set[Coin] = await select_coins(
|
|
single_greater_spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
single_greater_coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert single_greater_result is not None
|
|
assert sum([coin.amount for coin in single_greater_result]) > target_amount
|
|
assert len(single_greater_result) == 1
|
|
|
|
# test smallest greater than target with only multiple larger then target coins.
|
|
multiple_greater_coin_amounts = [90000, 100000, 120000, 200000, 100000]
|
|
multiple_greater_coin_list: List[WalletCoinRecord] = [
|
|
WalletCoinRecord(Coin(a_hash, a_hash, uint64(a)), uint32(1), uint32(1), False, True, WalletType(0), 1)
|
|
for a in multiple_greater_coin_amounts
|
|
]
|
|
multiple_greater_spendable_amount = uint128(sum(multiple_greater_coin_amounts))
|
|
target_amount = uint128(70000)
|
|
multiple_greater_result: Set[Coin] = await select_coins(
|
|
multiple_greater_spendable_amount,
|
|
DEFAULT_CONSTANTS.MAX_COIN_AMOUNT,
|
|
multiple_greater_coin_list,
|
|
{},
|
|
logging.getLogger("test"),
|
|
target_amount,
|
|
)
|
|
assert multiple_greater_result is not None
|
|
assert sum([coin.amount for coin in multiple_greater_result]) > target_amount
|
|
assert sum([coin.amount for coin in multiple_greater_result]) == 90000
|
|
assert len(multiple_greater_result) == 1
|