nurazhar
/
xch-blockchain
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove leading newlines from indented code blocks (#14653) 

* remove leading newlines from indented code blocks

* catch another one
This commit is contained in:
Kyle Altendorf 2023-02-23 19:53:48 -08:00 committed by GitHub
parent 9dcba09dda
commit ff5ef6e073
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
89 changed files with 0 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
benchmarks/block_ref.py
View File

@ -49,7 +49,6 @@ REPETITIONS = 100
async def main(db_path: Path):
random.seed(0x213FB154)
async with aiosqlite.connect(db_path) as connection:

2
benchmarks/block_store.py
View File

@ -40,7 +40,6 @@ random.seed(123456789)
async def run_add_block_benchmark(version: int):
verbose: bool = "--verbose" in sys.argv
db_wrapper: DBWrapper2 = await setup_db("block-store-benchmark.db", version)
@ -73,7 +72,6 @@ async def run_add_block_benchmark(version: int):
print("profiling add_full_block", end="")
for height in range(block_height, block_height + NUM_ITERS):
is_transaction = transaction_block_counter == 0
fees = uint64(random.randint(0, 150000))
farmer_coin, pool_coin = rewards(uint32(height))

4
benchmarks/coin_store.py
View File

@ -38,7 +38,6 @@ def make_coins(num: int) -> Tuple[List[Coin], List[bytes32]]:
async def run_new_block_benchmark(version: int):
verbose: bool = "--verbose" in sys.argv
db_wrapper: DBWrapper2 = await setup_db("coin-store-benchmark.db", version)
@ -56,7 +55,6 @@ async def run_new_block_benchmark(version: int):
print("Building database ", end="")
for height in range(block_height, block_height + NUM_ITERS):
# add some new coins
additions, hashes = make_coins(2000)
@ -94,7 +92,6 @@ async def run_new_block_benchmark(version: int):
if verbose:
print("Profiling mostly additions ", end="")
for height in range(block_height, block_height + NUM_ITERS):
# add some new coins
additions, hashes = make_coins(2000)
total_add += 2000
@ -193,7 +190,6 @@ async def run_new_block_benchmark(version: int):
total_remove = 0
total_time = 0
for height in range(block_height, block_height + NUM_ITERS):
# add some new coins
additions, hashes = make_coins(2000)
total_add += 2000

2
benchmarks/mempool.py
View File

@ -77,7 +77,6 @@ def fake_block_record(block_height: uint32, timestamp: uint64) -> BenchBlockReco
async def run_mempool_benchmark() -> None:
all_coins: Dict[bytes32, CoinRecord] = {}
async def get_coin_record(coin_id: bytes32) -> Optional[CoinRecord]:
@ -96,7 +95,6 @@ async def run_mempool_benchmark() -> None:
print("Building SpendBundles")
for peer in range(NUM_PEERS):
print(f" peer {peer}")
print(" reward coins")
unspent: List[Coin] = []

1
build_scripts/installer-version.py
View File

@ -5,7 +5,6 @@ from setuptools_scm import get_version
# example: 1.0b5.dev225
def main():
scm_full_version = get_version(root="..", relative_to=__file__)
# scm_full_version = "1.0.5.dev22"

1
chia/clvm/spend_sim.py
View File

@ -129,7 +129,6 @@ _T_SpendSim = TypeVar("_T_SpendSim", bound="SpendSim")
class SpendSim:
db_wrapper: DBWrapper2
coin_store: CoinStore
mempool_manager: MempoolManager

1
chia/cmds/check_wallet_db.py
View File

@ -369,7 +369,6 @@ class WalletDBReader:
async def scan(root_path: str, db_path: Optional[str] = None, *, verbose: bool = False) -> None:
if db_path is None:
wallet_db_path = Path(root_path) / "wallet" / "db"
wallet_db_paths = list(wallet_db_path.glob("blockchain_wallet_*.sqlite"))

1
chia/cmds/cmds_util.py
View File

@ -49,7 +49,6 @@ async def validate_client_connection(
fingerprint: Optional[int],
login_to_wallet: bool,
) -> Optional[int]:
try:
await rpc_client.healthz()
if type(rpc_client) == WalletRpcClient and login_to_wallet:

1
chia/cmds/db.py
View File

@ -32,7 +32,6 @@ def db_cmd() -> None:
)
@click.pass_context
def db_upgrade_cmd(ctx: click.Context, no_update_config: bool, force: bool, **kwargs) -> None:
try:
in_db_path = kwargs.get("input")
out_db_path = kwargs.get("output")

4
chia/cmds/db_upgrade_func.py
View File

@ -27,7 +27,6 @@ def db_upgrade_func(
no_update_config: bool = False,
force: bool = False,
) -> None:
update_config: bool = in_db_path is None and out_db_path is None and not no_update_config
config: Dict
@ -81,7 +80,6 @@ def db_upgrade_func(
except RuntimeError as e:
print(f"conversion failed with error: {e}.")
except Exception as e:
print(
textwrap.dedent(
f"""\
@ -202,10 +200,8 @@ def convert_v1_to_v2(in_path: Path, out_path: Path) -> None:
"SELECT header_hash, height, is_fully_compactified, block FROM full_blocks ORDER BY height DESC"
)
) as cursor_2:
out_db.execute("begin transaction")
for row in cursor:
header_hash = bytes.fromhex(row[0])
if header_hash != hh:
continue

3
chia/cmds/db_validate_func.py
View File

@ -41,7 +41,6 @@ def validate_v2(in_path: Path, *, validate_blocks: bool) -> None:
print(f"opening file for reading: {in_path}")
with closing(sqlite3.connect(in_path)) as in_db:
# read the database version
try:
with closing(in_db.execute("SELECT * FROM database_version")) as cursor:
@ -91,9 +90,7 @@ def validate_v2(in_path: Path, *, validate_blocks: bool) -> None:
"FROM full_blocks ORDER BY height DESC"
)
) as cursor:
for row in cursor:
hh = row[0]
prev = row[1]
height = row[2]

1
chia/consensus/blockchain.py
View File

@ -428,7 +428,6 @@ class Blockchain(BlockchainInterface):
async def get_tx_removals_and_additions(
self, block: FullBlock, npc_result: Optional[NPCResult] = None
) -> Tuple[List[bytes32], List[Coin], Optional[NPCResult]]:
if not block.is_transaction_block():
return [], [], None

2
chia/consensus/full_block_to_block_record.py
View File

@ -27,7 +27,6 @@ def block_to_block_record(
header_block: Optional[HeaderBlock],
sub_slot_iters: Optional[uint64] = None,
) -> BlockRecord:
if full_block is None:
assert header_block is not None
block: Union[HeaderBlock, FullBlock] = header_block
@ -99,7 +98,6 @@ def header_block_to_sub_block_record(
prev_transaction_block_height: uint32,
ses: Optional[SubEpochSummary],
) -> BlockRecord:
reward_claims_incorporated = (
block.transactions_info.reward_claims_incorporated if block.transactions_info is not None else None
)

1
chia/consensus/multiprocess_validation.py
View File

@ -116,7 +116,6 @@ def batch_pre_validate_blocks(
successfully_validated_signatures = False
# If we failed CLVM, no need to validate signature, the block is already invalid
if error_int is None:
# If this is False, it means either we don't have a signature (not a tx block) or we have an invalid
# signature (which also puts in an error) or we didn't validate the signature because we want to
# validate it later. receive_block will attempt to validate the signature later.

1
chia/data_layer/data_layer_server.py
View File

@ -117,7 +117,6 @@ class DataLayerServer:
async def async_start(root_path: Path) -> int:
shutdown_event = asyncio.Event()
dl_config = load_config(

1
chia/farmer/farmer.py
View File

@ -627,7 +627,6 @@ class Farmer:
for pool_state in self.pool_state.values():
pool_config: PoolWalletConfig = pool_state["pool_config"]
if pool_config.launcher_id == launcher_id:
authentication_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
if authentication_sk is None:
self.log.error(f"Could not find authentication sk for {pool_config.p2_singleton_puzzle_hash}")

3
chia/full_node/block_height_map.py
View File

@ -157,7 +157,6 @@ class BlockHeightMap:
# time until we hit a match in the existing map, at which point we can
# assume all previous blocks have already been populated
async def _load_blocks_from(self, height: uint32, prev_hash: bytes32) -> None:
while height > 0:
# load 5000 blocks at a time
window_end = max(0, height - 5000)
@ -175,7 +174,6 @@ class BlockHeightMap:
async with self.db.reader_no_transaction() as conn:
async with conn.execute(query, (window_end, height)) as cursor:
# maps block-hash -> (height, prev-hash, sub-epoch-summary)
ordered: Dict[bytes32, Tuple[uint32, bytes32, Optional[bytes]]] = {}
@ -195,7 +193,6 @@ class BlockHeightMap:
assert height == entry[0] + 1
height = entry[0]
if entry[2] is not None:
if (
self.get_hash(height) == prev_hash
and height in self.__sub_epoch_summaries

14
chia/full_node/block_store.py
View File

@ -34,10 +34,8 @@ class BlockStore:
self = cls(LRUCache(1000), db_wrapper, LRUCache(50))
async with self.db_wrapper.writer_maybe_transaction() as conn:
log.info("DB: Creating block store tables and indexes.")
if self.db_wrapper.db_version == 2:
# TODO: most data in block is duplicated in block_record. The only
# reason for this is that our parsing of a FullBlock is so slow,
# it's faster to store duplicate data to parse less when we just
@ -84,7 +82,6 @@ class BlockStore:
)
else:
await conn.execute(
"CREATE TABLE IF NOT EXISTS full_blocks(header_hash text PRIMARY KEY, height bigint,"
" is_block tinyint, is_fully_compactified tinyint, block blob)"
@ -168,7 +165,6 @@ class BlockStore:
raise RuntimeError(f"The blockchain database is corrupt. All of {header_hashes} should exist")
async def replace_proof(self, header_hash: bytes32, block: FullBlock) -> None:
assert header_hash == block.header_hash
block_bytes: bytes
@ -193,7 +189,6 @@ class BlockStore:
self.block_cache.put(header_hash, block)
if self.db_wrapper.db_version == 2:
ses: Optional[bytes] = (
None
if block_record.sub_epoch_summary_included is None
@ -331,7 +326,6 @@ class BlockStore:
return ret
async def get_block_info(self, header_hash: bytes32) -> Optional[GeneratorBlockInfo]:
cached = self.block_cache.get(header_hash)
if cached is not None:
log.debug(f"cache hit for block {header_hash.hex()}")
@ -362,7 +356,6 @@ class BlockStore:
)
async def get_generator(self, header_hash: bytes32) -> Optional[SerializedProgram]:
cached = self.block_cache.get(header_hash)
if cached is not None:
log.debug(f"cache hit for block {header_hash.hex()}")
@ -521,9 +514,7 @@ class BlockStore:
return ret
async def get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
if self.db_wrapper.db_version == 2:
async with self.db_wrapper.reader_no_transaction() as conn:
async with conn.execute(
"SELECT block_record FROM full_blocks WHERE header_hash=?",
@ -556,7 +547,6 @@ class BlockStore:
ret: Dict[bytes32, BlockRecord] = {}
if self.db_wrapper.db_version == 2:
async with self.db_wrapper.reader_no_transaction() as conn:
async with conn.execute(
"SELECT header_hash, block_record FROM full_blocks WHERE height >= ? AND height <= ?",
@ -567,7 +557,6 @@ class BlockStore:
ret[header_hash] = BlockRecord.from_bytes(row[1])
else:
formatted_str = f"SELECT header_hash, block from block_records WHERE height >= {start} and height <= {stop}"
async with self.db_wrapper.reader_no_transaction() as conn:
@ -601,7 +590,6 @@ class BlockStore:
return [maybe_decompress_blob(row[0]) for row in rows]
async def get_peak(self) -> Optional[Tuple[bytes32, uint32]]:
if self.db_wrapper.db_version == 2:
async with self.db_wrapper.reader_no_transaction() as conn:
async with conn.execute("SELECT hash FROM current_peak WHERE key = 0") as cursor:
@ -636,7 +624,6 @@ class BlockStore:
ret: Dict[bytes32, BlockRecord] = {}
if self.db_wrapper.db_version == 2:
async with self.db_wrapper.reader_no_transaction() as conn:
async with conn.execute(
"SELECT header_hash, block_record FROM full_blocks WHERE height >= ?",
@ -683,7 +670,6 @@ class BlockStore:
return bool(row[0])
async def get_random_not_compactified(self, number: int) -> List[int]:
if self.db_wrapper.db_version == 2:
async with self.db_wrapper.reader_no_transaction() as conn:
async with conn.execute(

10
chia/full_node/coin_store.py
View File

@ -36,10 +36,8 @@ class CoinStore:
self = CoinStore(db_wrapper, LRUCache(100))
async with self.db_wrapper.writer_maybe_transaction() as conn:
log.info("DB: Creating coin store tables and indexes.")
if self.db_wrapper.db_version == 2:
# the coin_name is unique in this table because the CoinStore always
# only represent a single peak
await conn.execute(
@ -55,7 +53,6 @@ class CoinStore:
)
else:
# the coin_name is unique in this table because the CoinStore always
# only represent a single peak
await conn.execute(
@ -273,7 +270,6 @@ class CoinStore:
start_height: uint32 = uint32(0),
end_height: uint32 = uint32((2**32) - 1),
) -> List[CoinRecord]:
coins = set()
async with self.db_wrapper.reader_no_transaction() as conn:
@ -284,7 +280,6 @@ class CoinStore:
f"{'' if include_spent_coins else 'AND spent_index=0'}",
(self.maybe_to_hex(puzzle_hash), start_height, end_height),
) as cursor:
for row in await cursor.fetchall():
coin = self.row_to_coin(row)
coins.add(CoinRecord(coin, row[0], row[1], row[2], row[6]))
@ -316,7 +311,6 @@ class CoinStore:
f"{'' if include_spent_coins else 'AND spent_index=0'}",
puzzle_hashes_db + (start_height, end_height),
) as cursor:
for row in await cursor.fetchall():
coin = self.row_to_coin(row)
coins.add(CoinRecord(coin, row[0], row[1], row[2], row[6]))
@ -348,7 +342,6 @@ class CoinStore:
f"{'' if include_spent_coins else 'AND spent_index=0'}",
names_db + (start_height, end_height),
) as cursor:
for row in await cursor.fetchall():
coin = self.row_to_coin(row)
coins.add(CoinRecord(coin, row[0], row[1], row[2], row[6]))
@ -427,7 +420,6 @@ class CoinStore:
f"{'' if include_spent_coins else 'AND spent_index=0'}",
parent_ids_db + (start_height, end_height),
) as cursor:
async for row in cursor:
coin = self.row_to_coin(row)
coins.add(CoinRecord(coin, row[0], row[1], row[2], row[6]))
@ -513,7 +505,6 @@ class CoinStore:
# Store CoinRecord in DB
async def _add_coin_records(self, records: List[CoinRecord]) -> None:
if self.db_wrapper.db_version == 2:
values2 = []
for record in records:
@ -560,7 +551,6 @@ class CoinStore:
# Update coin_record to be spent in DB
async def _set_spent(self, coin_names: List[bytes32], index: uint32) -> None:
assert len(coin_names) == 0 or index > 0
if len(coin_names) == 0:

1
chia/full_node/fee_tracker.py
View File

@ -511,7 +511,6 @@ class FeeTracker:
self.long_horizon.tx_confirmed(blocks_to_confirm, item)
def add_tx(self, item: MempoolItem) -> None:
if item.height_added_to_mempool < self.latest_seen_height:
self.log.info(f"Processing Item from pending pool: cost={item.cost} fee={item.fee}")

4
chia/full_node/full_node.py
View File

@ -2103,7 +2103,6 @@ class FullNode:
async def add_end_of_sub_slot(
self, end_of_slot_bundle: EndOfSubSlotBundle, peer: WSChiaConnection
) -> Tuple[Optional[Message], bool]:
fetched_ss = self.full_node_store.get_sub_slot(end_of_slot_bundle.challenge_chain.get_hash())
# We are not interested in sub-slots which have the same challenge chain but different reward chain. If there
@ -2355,7 +2354,6 @@ class FullNode:
header_hash: bytes32,
field_vdf: CompressibleVDFField,
) -> bool:
block = await self.block_store.get_full_block(header_hash)
if block is None:
return False
@ -2521,7 +2519,6 @@ class FullNode:
self.log.info("Heights found for bluebox to compact: [%s]" % ", ".join(map(str, heights)))
for h in heights:
headers = await self.blockchain.get_header_blocks_in_range(h, h, tx_filter=False)
records: Dict[bytes32, BlockRecord] = {}
if sanitize_weight_proof_only:
@ -2612,7 +2609,6 @@ class FullNode:
async def node_next_block_check(
peer: WSChiaConnection, potential_peek: uint32, blockchain: BlockchainInterface
) -> bool:
block_response: Optional[Any] = await peer.call_api(
FullNodeAPI.request_block, full_node_protocol.RequestBlock(potential_peek, True)
)

5
chia/full_node/full_node_api.py
View File

@ -558,7 +558,6 @@ class FullNodeAPI:
async def request_signage_point_or_end_of_sub_slot(
self, request: full_node_protocol.RequestSignagePointOrEndOfSubSlot
) -> Optional[Message]:
if request.index_from_challenge == 0:
sub_slot: Optional[Tuple[EndOfSubSlotBundle, int, uint128]] = self.full_node.full_node_store.get_sub_slot(
request.challenge_hash
@ -619,7 +618,6 @@ class FullNodeAPI:
return None
peak = self.full_node.blockchain.get_peak()
if peak is not None and peak.height > self.full_node.constants.MAX_SUB_SLOT_BLOCKS:
next_sub_slot_iters = self.full_node.blockchain.get_next_slot_iters(peak.header_hash, True)
sub_slots_for_peak = await self.full_node.blockchain.get_sp_and_ip_sub_slots(peak.header_hash)
assert sub_slots_for_peak is not None
@ -1096,7 +1094,6 @@ class FullNodeAPI:
tx_additions: List[Coin] = []
if block.transactions_generator is not None:
block_generator: Optional[BlockGenerator] = await self.full_node.blockchain.get_block_generator(block)
# get_block_generator() returns None in case the block we specify
# does not have a generator (i.e. is not a transaction block).
@ -1457,7 +1454,6 @@ class FullNodeAPI:
async def register_interest_in_puzzle_hash(
self, request: wallet_protocol.RegisterForPhUpdates, peer: WSChiaConnection
) -> Message:
trusted = self.is_trusted(peer)
if trusted:
max_subscriptions = self.full_node.config.get("trusted_max_subscribe_items", 2000000)
@ -1530,7 +1526,6 @@ class FullNodeAPI:
async def register_interest_in_coin(
self, request: wallet_protocol.RegisterForCoinUpdates, peer: WSChiaConnection
) -> Message:
if self.is_trusted(peer):
max_subscriptions = self.full_node.config.get("trusted_max_subscribe_items", 2000000)
max_items = self.full_node.config.get("trusted_max_subscribe_response_items", 500000)

2
chia/full_node/pending_tx_cache.py
View File

@ -34,7 +34,6 @@ class ConflictTxCache:
self._cache_cost += item.cost
while self._cache_cost > self._cache_max_total_cost or len(self._txs) > self._cache_max_size:
first_in = list(self._txs.keys())[0]
self._cache_cost -= self._txs[first_in].cost
self._txs.pop(first_in)
@ -77,7 +76,6 @@ class PendingTxCache:
self._by_height.setdefault(item.assert_height, {})[name] = item
while self._cache_cost > self._cache_max_total_cost or len(self._txs) > self._cache_max_size:
# we start removing items with the highest assert_height first
to_evict = self._by_height.items()[-1]
if to_evict[1] == {}:

1
chia/full_node/subscriptions.py
View File

@ -112,7 +112,6 @@ class PeerSubscriptions:
break
def remove_peer(self, peer_id: bytes32) -> None:
counter = 0
puzzle_hashes = self._peer_puzzle_hash.get(peer_id)
if puzzle_hashes is not None:

6
chia/full_node/weight_proof.py
View File

@ -54,7 +54,6 @@ def _create_shutdown_file() -> IO:
class WeightProofHandler:
LAMBDA_L = 100
C = 0.5
MAX_SAMPLES = 20
@ -74,7 +73,6 @@ class WeightProofHandler:
self.multiprocessing_context = multiprocessing_context
async def get_proof_of_weight(self, tip: bytes32) -> Optional[WeightProof]:
tip_rec = self.blockchain.try_block_record(tip)
if tip_rec is None:
log.error("unknown tip")
@ -859,7 +857,6 @@ def _validate_sub_epoch_summaries(
constants: ConsensusConstants,
weight_proof: WeightProof,
) -> Tuple[Optional[List[SubEpochSummary]], Optional[List[uint128]]]:
last_ses_hash, last_ses_sub_height = _get_last_ses_hash(constants, weight_proof.recent_chain_data)
if last_ses_hash is None:
log.warning("could not find last ses block")
@ -1074,7 +1071,6 @@ def _validate_sub_slot_data(
sub_slots: List[SubSlotData],
ssi: uint64,
) -> Tuple[bool, List[Tuple[VDFProof, ClassgroupElement, VDFInfo]]]:
sub_slot_data = sub_slots[sub_slot_idx]
assert sub_slot_idx > 0
prev_ssd = sub_slots[sub_slot_idx - 1]
@ -1381,7 +1377,6 @@ def __get_rc_sub_slot(
summaries: List[SubEpochSummary],
curr_ssi: uint64,
) -> RewardChainSubSlot:
ses = summaries[uint32(segment.sub_epoch_n - 1)]
# find first challenge in sub epoch
first_idx = None
@ -1646,7 +1641,6 @@ def _validate_vdf_batch(
vdf_list: List[Tuple[bytes, bytes, bytes]],
shutdown_file_path: Optional[pathlib.Path] = None,
):
for vdf_proof_bytes, class_group_bytes, info in vdf_list:
vdf = VDFProof.from_bytes(vdf_proof_bytes)
class_group = ClassgroupElement.from_bytes(class_group_bytes)

1
chia/rpc/full_node_rpc_api.py
View File

@ -466,7 +466,6 @@ class FullNodeRpcApi:
return {"block_record": record}
async def get_unfinished_block_headers(self, _request: Dict[str, Any]) -> EndpointResult:
peak: Optional[BlockRecord] = self.service.blockchain.get_peak()
if peak is None:
return {"headers": []}

1
chia/rpc/rpc_server.py
View File

@ -207,7 +207,6 @@ class RpcServer:
if change == "add_connection" or change == "close_connection" or change == "peer_changed_peak":
data = await self.get_connections({})
if data is not None:
payload = create_payload_dict(
"get_connections",
data,

3
chia/rpc/wallet_rpc_client.py
View File

@ -247,7 +247,6 @@ class WalletRpcClient(RpcClient):
exclude_amounts: Optional[List[uint64]] = None,
wallet_id: Optional[int] = None,
) -> List[TransactionRecord]:
# Converts bytes to hex for puzzle hashes
additions_hex = []
for ad in additions:
@ -308,7 +307,6 @@ class WalletRpcClient(RpcClient):
exclude_coins: Optional[List[Coin]] = None,
wallet_id: Optional[int] = None,
) -> TransactionRecord:
txs: List[TransactionRecord] = await self.create_signed_transactions(
additions=additions,
coins=coins,
@ -521,7 +519,6 @@ class WalletRpcClient(RpcClient):
p2_singleton_delay_time: Optional[uint64] = None,
p2_singleton_delayed_ph: Optional[bytes32] = None,
) -> TransactionRecord:
request: Dict[str, Any] = {
"wallet_type": "pool_wallet",
"mode": mode,

1
chia/seeder/crawler.py
View File

@ -100,7 +100,6 @@ class Crawler:
async def connect_task(self, peer):
async def peer_action(peer: WSChiaConnection):
peer_info = peer.get_peer_info()
version = peer.get_version()
if peer_info is not None and version is not None:

1
chia/server/node_discovery.py
View File

@ -600,7 +600,6 @@ class FullNodePeers(FullNodeDiscovery):
async def request_peers(self, peer_info: PeerInfo) -> Optional[Message]:
try:
# Prevent a fingerprint attack: do not send peers to inbound connections.
# This asymmetric behavior for inbound and outbound connections was introduced
# to prevent a fingerprinting attack: an attacker can send specific fake addresses

1
chia/server/rate_limits.py
View File

@ -72,7 +72,6 @@ class RateLimiter:
rate_limits = get_rate_limits_to_use(our_capabilities, peer_capabilities)
try:
limits: RLSettings = rate_limits["default_settings"]
if message_type in rate_limits["rate_limits_tx"]:
limits = rate_limits["rate_limits_tx"][message_type]

1
chia/server/server.py
View File

@ -160,7 +160,6 @@ class ChiaServer:
chia_ca_crt_key: Tuple[Path, Path],
name: str = __name__,
) -> ChiaServer:
log = logging.getLogger(name)
log.info("Service capabilities: %s", capabilities)

1
chia/server/ws_connection.py
View File

@ -137,7 +137,6 @@ class WSChiaConnection:
local_capabilities_for_handshake: List[Tuple[uint16, str]],
session: Optional[ClientSession] = None,
) -> WSChiaConnection:
assert ws._writer is not None
peername = ws._writer.transport.get_extra_info("peername")

3
chia/simulator/block_tools.py
View File

@ -147,7 +147,6 @@ test_constants = DEFAULT_CONSTANTS.replace(
def compute_additions_unchecked(sb: SpendBundle) -> List[Coin]:
ret: List[Coin] = []
for cs in sb.coin_spends:
parent_id = cs.coin.name()
_, r = cs.puzzle_reveal.run_with_cost(INFINITE_COST, cs.solution)
for cond in Program.to(r).as_iter():
@ -182,7 +181,6 @@ class BlockTools:
plot_dir: str = "test-plots",
log: logging.Logger = logging.getLogger(__name__),
):
self._block_cache_header = bytes32([0] * 32)
self._tempdir = None
@ -1285,7 +1283,6 @@ class BlockTools:
qualities = plot_info.prover.get_qualities_for_challenge(new_challenge)
for proof_index, quality_str in enumerate(qualities):
required_iters = calculate_iterations_quality(
constants.DIFFICULTY_CONSTANT_FACTOR,
quality_str,

1
chia/simulator/setup_nodes.py
View File

@ -290,7 +290,6 @@ async def setup_farmer_multi_harvester(
*,
start_services: bool,
) -> AsyncIterator[Tuple[List[Service[Harvester]], Service[Farmer], BlockTools]]:
farmer_node_iterators = [
setup_farmer(
block_tools,

1
chia/simulator/simulator_test_tools.py
View File

@ -136,7 +136,6 @@ async def get_full_chia_simulator(
keychain = Keychain()
with Lockfile.create(daemon_launch_lock_path(chia_root)):
mnemonic, fingerprint = mnemonic_fingerprint(keychain)
ssl_ca_cert_and_key_wrapper: SSLTestCollateralWrapper[

1
chia/types/blockchain_format/serialized_program.py
View File

@ -92,7 +92,6 @@ class SerializedProgram:
def run_as_generator(
self, max_cost: int, flags: int, *args: Union[Program, SerializedProgram]
) -> Tuple[Optional[int], Optional[SpendBundleConditions]]:
serialized_args = bytearray()
if len(args) > 1:
# when we have more than one argument, serialize them into a list

1
chia/types/blockchain_format/vdf.py
View File

@ -35,7 +35,6 @@ def verify_vdf(
discriminant_size: int,
witness_type: uint8,
):
return verify_n_wesolowski(
str(disc),
input_el,

1
chia/util/full_block_utils.py
View File

@ -31,7 +31,6 @@ def skip_bytes(buf: memoryview) -> memoryview:
def skip_optional(buf: memoryview, skip_item: Callable[[memoryview], memoryview]) -> memoryview:
if buf[0] == 0:
return buf[1:]
assert buf[0] == 1

2
chia/util/misc.py
View File

@ -19,7 +19,6 @@ class VersionedBlob(Streamable):
def format_bytes(bytes: int) -> str:
if not isinstance(bytes, int) or bytes < 0:
return "Invalid"
@ -35,7 +34,6 @@ def format_bytes(bytes: int) -> str:
def format_minutes(minutes: int) -> str:
if not isinstance(minutes, int):
return "Invalid"

3
chia/util/profiler.py
View File

@ -24,7 +24,6 @@ from chia.util.path import path_from_root
async def profile_task(root_path: pathlib.Path, service: str, log: logging.Logger) -> None:
profile_dir = path_from_root(root_path, f"profile-{service}")
log.info("Starting profiler. saving to %s" % profile_dir)
profile_dir.mkdir(parents=True, exist_ok=True)
@ -70,7 +69,6 @@ if __name__ == "__main__":
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.000 0.000 0.000 0.000 <function>
for line in f:
if " function calls " in line and " in " in line and " seconds":
# 304307 function calls (291692 primitive calls) in 1.031 seconds
assert total == 0
@ -160,7 +158,6 @@ profiler.py <profile-directory> <first-slot> <last-slot>
async def mem_profile_task(root_path: pathlib.Path, service: str, log: logging.Logger) -> None:
profile_dir = path_from_root(root_path, f"memory-profile-{service}") / datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
log.info("Starting memory profiler. saving to %s" % profile_dir)
profile_dir.mkdir(parents=True, exist_ok=True)

5
chia/util/task_timing.py
View File

@ -155,7 +155,6 @@ def get_file(frame: FrameType) -> str:
def trace_fun(frame: FrameType, event: str, arg: Any) -> None:
if event in ["c_call", "c_return", "c_exception"]:
return
@ -198,7 +197,6 @@ def trace_fun(frame: FrameType, event: str, arg: Any) -> None:
# f.write(f"{indent}CALL {t} {get_stack(frame)}\n")
elif event == "return":
fi = ti.stack.get(frame)
assert fi is not None
@ -210,7 +208,6 @@ def trace_fun(frame: FrameType, event: str, arg: Any) -> None:
# with open("instrumentation.log", "a") as f:
# f.write(f"{indent}SUSPEND {t} {get_stack(frame)}\n")
else:
# with open("instrumentation.log", "a") as f:
# f.write(f"{indent}RETURN {t} {get_stack(frame)}\n")
@ -290,7 +287,6 @@ def stop_task_instrumentation(target_dir: str = f"task-profile-{os.getpid()}") -
# print all nodes (functions)
for name, fun_info in call_tree.items():
# frames that are less than 0.1% of the total wall-clock time are
# filtered
if fun_info.duration / total_duration < 0.001:
@ -310,7 +306,6 @@ def stop_task_instrumentation(target_dir: str = f"task-profile-{os.getpid()}") -
# print all edges (calls)
for name, fun_info in call_tree.items():
if name in filter_frames:
continue

1
chia/wallet/cat_wallet/lineage_store.py
View File

@ -48,7 +48,6 @@ class CATLineageStore:
await cursor.close()
async def get_lineage_proof(self, coin_id: bytes32) -> Optional[LineageProof]:
async with self.db_wrapper.reader_no_transaction() as conn:
cursor = await conn.execute(
f"SELECT * FROM {self.table_name} WHERE coin_id=?;",

1
chia/wallet/derive_keys.py
View File

@ -115,7 +115,6 @@ def match_address_to_sk(
search_list: Set[bytes32] = set(addresses_to_search)
for i in range(max_ph_to_search):
phs = [
create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(i)).get_g1()),
create_puzzlehash_for_pk(master_sk_to_wallet_sk_unhardened(sk, uint32(i)).get_g1()),

2
chia/wallet/did_wallet/did_wallet.py
View File

@ -1178,7 +1178,6 @@ class DIDWallet:
raise ValueError("Missing DID inner puzzle.")
puzzle_args = did_wallet_puzzles.uncurry_innerpuz(self.did_info.current_inner)
if puzzle_args is not None:
p2_puzzle, _, _, _, _ = puzzle_args
puzzle_hash = p2_puzzle.get_tree_hash()
pubkey, private = await self.wallet_state_manager.get_keys(puzzle_hash)
@ -1195,7 +1194,6 @@ class DIDWallet:
async def sign(self, spend_bundle: SpendBundle) -> SpendBundle:
sigs: List[G2Element] = []
for spend in spend_bundle.coin_spends:
puzzle_args = did_wallet_puzzles.match_did_puzzle(*spend.puzzle_reveal.to_program().uncurry())
if puzzle_args is not None:
p2_puzzle, _, _, _, _ = puzzle_args

1
chia/wallet/notification_store.py
View File

@ -140,7 +140,6 @@ class NotificationStore:
]
async def delete_notifications(self, coin_ids: List[bytes32]) -> None:
coin_ids_str_list = "("
for _ in coin_ids:
coin_ids_str_list += "?"

1
chia/wallet/trade_manager.py
View File

@ -585,7 +585,6 @@ class TradeManager:
return False, None, str(e)
async def maybe_create_wallets_for_offer(self, offer: Offer) -> None:
for key in offer.arbitrage():
wsm = self.wallet_state_manager
if key is None:

1
chia/wallet/trading/trade_store.py
View File

@ -482,7 +482,6 @@ class TradeStore:
return records
async def rollback_to_block(self, block_index: int) -> None:
async with self.db_wrapper.writer_maybe_transaction() as conn:
# Delete from storage
cursor = await conn.execute("DELETE FROM trade_records WHERE confirmed_at_index>?", (block_index,))

1
chia/wallet/wallet_coin_store.py
View File

@ -106,7 +106,6 @@ class WalletCoinStore:
# Update coin_record to be spent in DB
async def set_spent(self, coin_name: bytes32, height: uint32) -> None:
async with self.db_wrapper.writer_maybe_transaction() as conn:
await conn.execute_insert(
"UPDATE coin_record SET spent_height=?,spent=? WHERE coin_name=?",

2
chia/wallet/wallet_interested_store.py
View File

@ -39,7 +39,6 @@ class WalletInterestedStore:
return [bytes32(bytes.fromhex(row[0])) for row in rows_hex]
async def add_interested_coin_id(self, coin_id: bytes32) -> None:
async with self.db_wrapper.writer_maybe_transaction() as conn:
cursor = await conn.execute("INSERT OR REPLACE INTO interested_coins VALUES (?)", (coin_id.hex(),))
await cursor.close()
@ -61,7 +60,6 @@ class WalletInterestedStore:
return row[0]
async def add_interested_puzzle_hash(self, puzzle_hash: bytes32, wallet_id: int) -> None:
async with self.db_wrapper.writer_maybe_transaction() as conn:
cursor = await conn.execute(
"INSERT OR REPLACE INTO interested_puzzle_hashes VALUES (?, ?)", (puzzle_hash.hex(), wallet_id)

1
chia/wallet/wallet_node.py
View File

@ -1673,7 +1673,6 @@ class WalletNode:
async def fetch_children(
self, coin_name: bytes32, peer: WSChiaConnection, fork_height: Optional[uint32] = None
) -> List[CoinState]:
response: Optional[wallet_protocol.RespondChildren] = await peer.call_api(
FullNodeAPI.request_children, wallet_protocol.RequestChildren(coin_name)
)

1
chia/wallet/wallet_protocol.py
View File

@ -16,7 +16,6 @@ if TYPE_CHECKING:
class WalletProtocol(Protocol):
# TODO: it seems like this should return WalletType instead
@classmethod
def type(cls) -> uint8:

1
chia/wallet/wallet_user_store.py
View File

@ -53,7 +53,6 @@ class WalletUserStore:
data: str,
id: Optional[int] = None,
) -> WalletInfo:
async with self.db_wrapper.writer_maybe_transaction() as conn:
cursor = await conn.execute(
"INSERT INTO users_wallets VALUES(?, ?, ?, ?)",

2
tests/blockchain/test_blockchain.py
View File

@ -1733,7 +1733,6 @@ class TestPreValidation:
class TestBodyValidation:
# TODO: add test for
# ASSERT_COIN_ANNOUNCEMENT,
# CREATE_COIN_ANNOUNCEMENT,
@ -3316,7 +3315,6 @@ async def test_reorg_flip_flop(empty_blockchain, bt):
counter = 0
for b1, b2 in zip(chain_a, chain_b):
# alternate the order we add blocks from the two chains, to ensure one
# chain overtakes the other one in weight every other time
if counter % 2 == 0:

5
tests/blockchain/test_blockchain_transactions.py
View File

@ -510,7 +510,6 @@ class TestBlockchainTransactions:
@pytest.mark.asyncio
async def test_assert_coin_announcement_consumed(self, two_nodes):
num_blocks = 10
wallet_a = WALLET_A
coinbase_puzzlehash = WALLET_A_PUZZLE_HASHES[0]
@ -592,7 +591,6 @@ class TestBlockchainTransactions:
@pytest.mark.asyncio
async def test_assert_puzzle_announcement_consumed(self, two_nodes):
num_blocks = 10
wallet_a = WALLET_A
coinbase_puzzlehash = WALLET_A_PUZZLE_HASHES[0]
@ -804,7 +802,6 @@ class TestBlockchainTransactions:
@pytest.mark.asyncio
async def test_assert_seconds_relative(self, two_nodes):
num_blocks = 10
wallet_a = WALLET_A
coinbase_puzzlehash = WALLET_A_PUZZLE_HASHES[0]
@ -862,7 +859,6 @@ class TestBlockchainTransactions:
@pytest.mark.asyncio
async def test_assert_seconds_absolute(self, two_nodes):
num_blocks = 10
wallet_a = WALLET_A
coinbase_puzzlehash = WALLET_A_PUZZLE_HASHES[0]
@ -921,7 +917,6 @@ class TestBlockchainTransactions:
@pytest.mark.asyncio
async def test_assert_fee_condition(self, two_nodes):
num_blocks = 10
wallet_a = WALLET_A
coinbase_puzzlehash = WALLET_A_PUZZLE_HASHES[0]

1
tests/check_sql_statements.py
View File

@ -9,7 +9,6 @@ from typing import Dict, Set, Tuple
def check_create(sql_type: str, cwd: str, exemptions: Set[Tuple[str, str]] = set()) -> int:
lines = check_output(["git", "grep", f"CREATE {sql_type}"], cwd=cwd).decode("ascii").split("\n")
ret = 0

1
tests/clvm/test_puzzles.py
View File

@ -96,7 +96,6 @@ def do_test_spend(
def default_payments_and_conditions(
initial_index: int, key_lookup: KeyTool
) -> Tuple[List[Tuple[bytes32, int]], Program]:
# the coin we get from coin_db.farm_coin only has amount 1024, so we can
# only make small payments to avoid failing with MINTING_COIN
payments = [

4
tests/core/custom_types/test_coin.py
View File

@ -11,7 +11,6 @@ from chia.util.ints import uint64
def coin_serialize(amount: uint64, clvm_serialize: bytes, full_serialize: bytes):
c = Coin(bytes32(b"a" * 32), bytes32(b"b" * 32), amount)
expected_hash = (b"a" * 32) + (b"b" * 32) + clvm_serialize
@ -27,7 +26,6 @@ def coin_serialize(amount: uint64, clvm_serialize: bytes, full_serialize: bytes)
def test_serialization():
coin_serialize(uint64(0xFFFF), bytes([0, 0xFF, 0xFF]), bytes([0, 0, 0, 0, 0, 0, 0xFF, 0xFF]))
coin_serialize(uint64(1337000000), bytes([0x4F, 0xB1, 0x00, 0x40]), bytes([0, 0, 0, 0, 0x4F, 0xB1, 0x00, 0x40]))
@ -68,7 +66,6 @@ def test_serialization():
],
)
def test_name(amount: int, clvm: List[int]) -> None:
H1 = bytes32(b"a" * 32)
H2 = bytes32(b"b" * 32)
@ -76,7 +73,6 @@ def test_name(amount: int, clvm: List[int]) -> None:
def test_construction() -> None:
H1 = b"a" * 32
H2 = b"b" * 32

5
tests/core/full_node/stores/test_block_store.py
View File

@ -32,7 +32,6 @@ async def test_block_store(tmp_dir, db_version, bt):
blocks = bt.get_consecutive_blocks(10)
async with DBConnection(db_version) as db_wrapper, DBConnection(db_version) as db_wrapper_2:
# Use a different file for the blockchain
coin_store_2 = await CoinStore.create(db_wrapper_2)
store_2 = await BlockStore.create(db_wrapper_2)
@ -88,7 +87,6 @@ async def test_deadlock(tmp_dir, db_version, bt):
blocks = bt.get_consecutive_blocks(10)
async with DBConnection(db_version) as wrapper, DBConnection(db_version) as wrapper_2:
store = await BlockStore.create(wrapper)
coin_store_2 = await CoinStore.create(wrapper_2)
store_2 = await BlockStore.create(wrapper_2)
@ -117,7 +115,6 @@ async def test_rollback(bt, tmp_dir):
blocks = bt.get_consecutive_blocks(10)
async with DBConnection(2) as db_wrapper:
# Use a different file for the blockchain
coin_store = await CoinStore.create(db_wrapper)
block_store = await BlockStore.create(db_wrapper)
@ -286,7 +283,6 @@ async def test_get_blocks_by_hash(tmp_dir, bt, db_version):
blocks = bt.get_consecutive_blocks(10)
async with DBConnection(db_version) as db_wrapper, DBConnection(db_version) as db_wrapper_2:
# Use a different file for the blockchain
coin_store_2 = await CoinStore.create(db_wrapper_2)
store_2 = await BlockStore.create(db_wrapper_2)
@ -324,7 +320,6 @@ async def test_get_block_bytes_in_range(tmp_dir, bt, db_version):
blocks = bt.get_consecutive_blocks(10)
async with DBConnection(db_version) as db_wrapper_2:
# Use a different file for the blockchain
coin_store_2 = await CoinStore.create(db_wrapper_2)
store_2 = await BlockStore.create(db_wrapper_2)

2
tests/core/full_node/stores/test_coin_store.py
View File

@ -318,7 +318,6 @@ class TestCoinStoreWithBlocks:
@pytest.mark.asyncio
async def test_basic_reorg(self, tmp_dir, db_version, bt):
async with DBConnection(db_version) as db_wrapper:
initial_block_count = 30
reorg_length = 15
@ -327,7 +326,6 @@ class TestCoinStoreWithBlocks:
store = await BlockStore.create(db_wrapper)
b: Blockchain = await Blockchain.create(coin_store, store, test_constants, tmp_dir, 2)
try:
records: List[Optional[CoinRecord]] = []
for block in blocks:

16
tests/core/full_node/test_block_height_map.py
View File

@ -64,7 +64,6 @@ async def new_block(
async def setup_db(db: DBWrapper2):
async with db.writer_maybe_transaction() as conn:
if db.db_version == 2:
await conn.execute(
@ -118,7 +117,6 @@ async def setup_chain(
class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_height_to_hash(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10)
@ -134,7 +132,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_height_to_hash_long_chain(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10000)
@ -149,7 +146,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_save_restore(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10000, ses_every=20)
@ -194,12 +190,10 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_restore_entire_chain(self, tmp_dir, db_version):
# this is a test where the height-to-hash and height-to-ses caches are
# entirely unrelated to the database. Make sure they can both be fully
# replaced
async with DBConnection(db_version) as db_wrapper:
heights = bytearray(900 * 32)
for i in range(900):
idx = i * 32
@ -229,7 +223,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_restore_extend(self, tmp_dir, db_version):
# test the case where the cache has fewer blocks than the DB, and that
# we correctly load all the missing blocks from the DB to update the
# cache
@ -270,7 +263,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_height_to_hash_with_orphans(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10)
@ -286,7 +278,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_height_to_hash_update(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10)
@ -308,7 +299,6 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_update_ses(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10)
@ -328,9 +318,7 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_height_to_ses(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10, ses_every=2)
@ -355,9 +343,7 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_rollback(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10, ses_every=2)
@ -393,9 +379,7 @@ class TestBlockHeightMap:
@pytest.mark.asyncio
async def test_rollback2(self, tmp_dir, db_version):
async with DBConnection(db_version) as db_wrapper:
await setup_db(db_wrapper)
await setup_chain(db_wrapper, 10, ses_every=2)

53
tests/core/mempool/test_mempool.py
View File

@ -280,7 +280,6 @@ class TestPendingTxCache:
class TestMempool:
@pytest.mark.asyncio
async def test_basic_mempool(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -394,7 +393,6 @@ class TestMempoolManager:
)
async def test_ephemeral_timelock(self, one_node_one_block, wallet_a, opcode, lock_value, expected):
def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
conditions = {opcode: [ConditionWithArgs(opcode, [int_to_bytes(lock_value)])]}
tx1 = wallet_a.generate_signed_transaction(
uint64(1000000), wallet_a.get_new_puzzlehash(), coin_2, conditions.copy(), uint64(0)
@ -725,7 +723,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_block_index(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
blocks = await full_node_1.get_all_full_blocks()
start_height = blocks[-1].height
@ -743,7 +740,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_block_index_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [])
dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
@ -756,7 +752,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_block_index(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [int_to_bytes(1)])
dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
@ -768,7 +763,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_block_index_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
# garbage at the end of the argument list is ignored in consensus mode,
# but not in mempool-mode
@ -782,7 +776,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_negative_block_index(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [int_to_bytes(-1)])
dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
@ -794,7 +787,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_block_age(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(5)])
dic = {cvp.opcode: [cvp]}
@ -807,7 +799,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_block_age_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [])
dic = {cvp.opcode: [cvp]}
@ -820,7 +811,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_block_age(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(1)])
dic = {cvp.opcode: [cvp]}
@ -835,7 +825,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_block_age_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
# garbage at the end of the argument list is ignored in consensus mode,
# but not in mempool mode
@ -852,7 +841,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_negative_block_age(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(-1)])
dic = {cvp.opcode: [cvp]}
@ -867,7 +855,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_my_id(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -886,7 +873,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_id_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -907,7 +893,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_my_id(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -927,7 +912,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_id_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [])
dic = {cvp.opcode: [cvp]}
@ -940,7 +924,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_exceeds(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
# 5 seconds should be before the next block
time_now = full_node_1.full_node.blockchain.get_peak().timestamp + 5
@ -955,7 +938,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_fail(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_now = full_node_1.full_node.blockchain.get_peak().timestamp + 1000
@ -969,7 +951,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_height_pending(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
print(full_node_1.full_node.blockchain.get_peak())
current_height = full_node_1.full_node.blockchain.get_peak().height
@ -984,7 +965,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_negative(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_now = -1
@ -998,7 +978,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_ABSOLUTE, [])
@ -1011,7 +990,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_now = full_node_1.full_node.blockchain.get_peak().timestamp + 5
@ -1027,7 +1005,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_relative_exceeds(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_relative = 3
@ -1054,7 +1031,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_relative_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_relative = 0
@ -1071,7 +1047,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_relative_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_RELATIVE, [])
@ -1085,7 +1060,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_time_relative_negative(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
time_relative = -3
@ -1481,7 +1455,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_fee_condition(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(10)])
dic = {cvp.opcode: [cvp]}
@ -1496,7 +1469,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_fee_condition_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
# garbage at the end of the arguments is ignored in consensus mode, but
# not in mempool mode
@ -1563,7 +1535,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_assert_fee_condition_wrong_fee(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(10)])
@ -1726,7 +1697,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_my_parent(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1746,7 +1716,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_parent_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1768,7 +1737,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_parent_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PARENT_ID, [])
dic = {cvp.opcode: [cvp]}
@ -1782,7 +1750,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_my_parent(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1803,7 +1770,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_my_puzhash(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1823,7 +1789,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_puzhash_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1844,7 +1809,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_puzhash_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PUZZLEHASH, [])
dic = {cvp.opcode: [cvp]}
@ -1858,7 +1822,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_my_puzhash(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1878,7 +1841,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_correct_my_amount(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1898,7 +1860,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_amount_garbage(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
_ = await next_block(full_node_1, wallet_a, bt)
@ -1920,7 +1881,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_amount_missing_arg(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [])
dic = {cvp.opcode: [cvp]}
@ -1934,7 +1894,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_invalid_my_amount(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(1000)])
dic = {cvp.opcode: [cvp]}
@ -1948,7 +1907,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_negative_my_amount(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(-1)])
dic = {cvp.opcode: [cvp]}
@ -1962,7 +1920,6 @@ class TestMempoolManager:
@pytest.mark.asyncio
async def test_my_amount_too_large(self, one_node_one_block, wallet_a):
full_node_1, server_1, bt = one_node_one_block
cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(2**64)])
dic = {cvp.opcode: [cvp]}
@ -2003,7 +1960,6 @@ def generator_condition_tester(
class TestGeneratorConditions:
def test_invalid_condition_args_terminator(self, softfork_height):
# note how the condition argument list isn't correctly terminated with a
# NIL atom. This is allowed, and all arguments beyond the ones we look
# at are ignored, including the termination of the list
@ -2022,7 +1978,6 @@ class TestGeneratorConditions:
],
)
def test_div(self, mempool, operand, expected, softfork_height):
# op_div is disallowed on negative numbers in the mempool, and after the
# softfork
npc_result = generator_condition_tester(
@ -2034,7 +1989,6 @@ class TestGeneratorConditions:
assert npc_result.error == expected
def test_invalid_condition_list_terminator(self, softfork_height):
# note how the list of conditions isn't correctly terminated with a
# NIL atom. This is a failure
npc_result = generator_condition_tester("(80 50) . 3", height=softfork_height)
@ -2168,7 +2122,6 @@ class TestGeneratorConditions:
assert npc_result.error in [Err.BLOCK_COST_EXCEEDS_MAX.value, Err.INVALID_BLOCK_COST.value]
def test_create_coin_different_parent(self, softfork_height):
# if the coins we create have different parents, they are never
# considered duplicate, even when they have the same puzzle hash and
# amount
@ -2353,7 +2306,6 @@ def error_for_condition(cond: ConditionOpcode) -> int:
class TestMaliciousGenerators:
# TODO: create a lot of announcements. The messages can be made different by
# using substr on a large buffer
@ -2555,7 +2507,6 @@ def softfork_fixture(request):
class TestPkmPairs:
h1 = bytes32(b"a" * 32)
h2 = bytes32(b"b" * 32)
h3 = bytes32(b"c" * 32)
@ -2579,7 +2530,6 @@ class TestPkmPairs:
assert msgs == []
def test_agg_sig_me(self, softfork):
spends = [
Spend(
self.h1,
@ -2607,7 +2557,6 @@ class TestPkmPairs:
assert msgs == [b"msg1", b"msg2"]
def test_agg_sig_mixed(self, softfork):
spends = [Spend(self.h1, self.h2, None, 0, None, None, [], [(bytes48(self.pk1), b"msg1")], 0)]
conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [(bytes48(self.pk2), b"msg2")], 0)
pks, msgs = pkm_pairs(conds, b"foobar", soft_fork=softfork)
@ -2640,14 +2589,12 @@ class TestPkmPairs:
class TestPkmPairsForConditionDict:
h1 = bytes32(b"a" * 32)
pk1 = G1Element.generator()
pk2 = G1Element.generator()
def test_agg_sig_unsafe_restriction(self) -> None:
ASU = ConditionOpcode.AGG_SIG_UNSAFE
conds = {ASU: [ConditionWithArgs(ASU, [self.pk1, b"msg1"]), ConditionWithArgs(ASU, [self.pk2, b"msg2"])]}

1
tests/core/mempool/test_mempool_fee_estimator.py
View File

@ -90,7 +90,6 @@ async def test_basics() -> None:
@pytest.mark.asyncio
async def test_fee_increase() -> None:
async with DBConnection(db_version=2) as db_wrapper:
coin_store = await CoinStore.create(db_wrapper)
mempool_manager = MempoolManager(coin_store.get_coin_record, test_constants)

2
tests/core/mempool/test_mempool_manager.py
View File

@ -117,7 +117,6 @@ def make_test_conds(
class TestCheckTimeLocks:
COIN_CONFIRMED_HEIGHT = uint32(10)
COIN_TIMESTAMP = uint64(10000)
PREV_BLOCK_HEIGHT = uint32(15)
@ -210,7 +209,6 @@ class TestCheckTimeLocks:
def test_compute_assert_height() -> None:
c1 = Coin(bytes32(b"a" * 32), bytes32(b"b" * 32), 1337)
coin_id = c1.name()
confirmed_height = uint32(12)

2
tests/core/test_cost_calculation.py
View File

@ -218,7 +218,6 @@ class TestCostCalculation:
@pytest.mark.asyncio
async def test_clvm_max_cost(self, softfork_height):
block = Program.from_bytes(bytes(SMALL_BLOCK_GENERATOR.program))
disassembly = binutils.disassemble(block)
# this is a valid generator program except the first clvm
@ -280,7 +279,6 @@ class TestCostCalculation:
@pytest.mark.asyncio
@pytest.mark.benchmark
async def test_get_puzzle_and_solution_for_coin_performance():
from clvm.casts import int_from_bytes
from chia.full_node.mempool_check_conditions import DESERIALIZE_MOD

2
tests/core/test_db_conversion.py
View File

@ -30,7 +30,6 @@ class TestDbUpgrade:
@pytest.mark.asyncio
@pytest.mark.parametrize("with_hints", [True, False])
async def test_blocks(self, default_1000_blocks, with_hints: bool):
blocks = default_1000_blocks
hints: List[Tuple[bytes32, bytes]] = []
@ -54,7 +53,6 @@ class TestDbUpgrade:
hints.append((coin_id, hint))
with TempFile() as in_file, TempFile() as out_file:
db_wrapper1 = await DBWrapper2.create(
database=in_file,
reader_count=1,

1
tests/core/test_db_validation.py
View File

@ -151,7 +151,6 @@ async def make_db(db_file: Path, blocks: List[FullBlock]) -> None:
@pytest.mark.asyncio
async def test_db_validate_default_1000_blocks(default_1000_blocks: List[FullBlock]) -> None:
with TempFile() as db_file:
await make_db(db_file, default_1000_blocks)

1
tests/core/util/test_jsonify.py
View File

@ -142,6 +142,5 @@ def test_nested() -> None:
def test_recurse_jsonify() -> None:
d = {"a": "foo", "b": bytes([0x13, 0x37]), "c": [uint32(1), uint32(2)], "d": {"bar": None}}
assert recurse_jsonify(d) == {"a": "foo", "b": "0x1337", "c": [1, 2], "d": {"bar": None}}

16
tests/core/util/test_streamable.py
View File

@ -79,7 +79,6 @@ class DataclassOnly:
def test_pure_dataclass_not_supported() -> None:
with pytest.raises(UnsupportedType):
@streamable
@ -93,7 +92,6 @@ class PlainClass:
def test_plain_class_not_supported() -> None:
with pytest.raises(UnsupportedType):
@streamable
@ -141,7 +139,6 @@ class ConvertTupleFailures(Streamable):
],
)
def test_convert_tuple_failures(input_dict: Dict[str, Any], error: Any) -> None:
with pytest.raises(error):
streamable_from_dict(ConvertTupleFailures, input_dict)
@ -165,7 +162,6 @@ class ConvertListFailures(Streamable):
],
)
def test_convert_list_failures(input_dict: Dict[str, Any], error: Any) -> None:
with pytest.raises(error):
streamable_from_dict(ConvertListFailures, input_dict)
@ -195,7 +191,6 @@ class ConvertByteTypeFailures(Streamable):
],
)
def test_convert_byte_type_failures(input_dict: Dict[str, Any], error: Any) -> None:
with pytest.raises(error):
streamable_from_dict(ConvertByteTypeFailures, input_dict)
@ -221,7 +216,6 @@ class ConvertUnhashableTypeFailures(Streamable):
],
)
def test_convert_unhashable_type_failures(input_dict: Dict[str, Any], error: Any) -> None:
with pytest.raises(error):
streamable_from_dict(ConvertUnhashableTypeFailures, input_dict)
@ -248,7 +242,6 @@ class ConvertPrimitiveFailures(Streamable):
],
)
def test_convert_primitive_failures(input_dict: Dict[str, Any], error: Any) -> None:
with pytest.raises(error):
streamable_from_dict(ConvertPrimitiveFailures, input_dict)
@ -321,7 +314,6 @@ def test_convert_primitive_failures(input_dict: Dict[str, Any], error: Any) -> N
def test_streamable_from_dict_failures(
test_class: Type[Streamable], input_dict: Dict[str, Any], error: Any, error_message: str
) -> None:
with pytest.raises(error, match=re.escape(error_message)):
streamable_from_dict(test_class, input_dict)
@ -742,7 +734,6 @@ def test_parse_optional() -> None:
def test_parse_bytes() -> None:
assert parse_bytes(io.BytesIO(b"\x00\x00\x00\x00")) == b""
assert parse_bytes(io.BytesIO(b"\x00\x00\x00\x01\xff")) == b"\xff"
@ -768,7 +759,6 @@ def test_parse_bytes() -> None:
def test_parse_list() -> None:
assert parse_list(io.BytesIO(b"\x00\x00\x00\x00"), parse_bool) == []
assert parse_list(io.BytesIO(b"\x00\x00\x00\x01\x01"), parse_bool) == [True]
assert parse_list(io.BytesIO(b"\x00\x00\x00\x03\x01\x00\x01"), parse_bool) == [True, False, True]
@ -789,7 +779,6 @@ def test_parse_list() -> None:
def test_parse_tuple() -> None:
assert parse_tuple(io.BytesIO(b""), []) == ()
assert parse_tuple(io.BytesIO(b"\x00\x00"), [parse_bool, parse_bool]) == (False, False)
assert parse_tuple(io.BytesIO(b"\x00\x01"), [parse_bool, parse_bool]) == (False, True)
@ -832,7 +821,6 @@ def test_parse_size_hints() -> None:
def test_parse_str() -> None:
assert parse_str(io.BytesIO(b"\x00\x00\x00\x00")) == ""
assert parse_str(io.BytesIO(b"\x00\x00\x00\x01a")) == "a"
@ -858,7 +846,6 @@ def test_parse_str() -> None:
def test_wrong_decorator_order() -> None:
with pytest.raises(DefinitionError):
@dataclass(frozen=True)
@ -868,7 +855,6 @@ def test_wrong_decorator_order() -> None:
def test_dataclass_not_frozen() -> None:
with pytest.raises(DefinitionError):
@streamable
@ -878,7 +864,6 @@ def test_dataclass_not_frozen() -> None:
def test_dataclass_missing() -> None:
with pytest.raises(DefinitionError):
@streamable
@ -887,7 +872,6 @@ def test_dataclass_missing() -> None:
def test_streamable_inheritance_missing() -> None:
with pytest.raises(DefinitionError):
# we want to test invalid here, hence the ignore.
@streamable

3
tests/db/test_db_wrapper.py
View File

@ -106,7 +106,6 @@ def get_reader_method_fixture(request: SubRequest) -> Callable[[], ConnectionCon
argvalues=[pytest.param(False, id="not acquired outside"), pytest.param(True, id="acquired outside")],
)
async def test_concurrent_writers(acquire_outside: bool, get_reader_method: GetReaderMethod) -> None:
async with DBConnection(2) as db_wrapper:
await setup_table(db_wrapper)
@ -326,7 +325,6 @@ async def test_reader_transaction_is_deferred() -> None:
argvalues=[pytest.param(False, id="not acquired outside"), pytest.param(True, id="acquired outside")],
)
async def test_concurrent_readers(acquire_outside: bool, get_reader_method: GetReaderMethod) -> None:
async with DBConnection(2) as db_wrapper:
await setup_table(db_wrapper)
@ -356,7 +354,6 @@ async def test_concurrent_readers(acquire_outside: bool, get_reader_method: GetR
argvalues=[pytest.param(False, id="not acquired outside"), pytest.param(True, id="acquired outside")],
)
async def test_mixed_readers_writers(acquire_outside: bool, get_reader_method: GetReaderMethod) -> None:
async with DBConnection(2) as db_wrapper:
await setup_table(db_wrapper)

1
tests/util/benchmark_cost.py
View File

@ -32,7 +32,6 @@ def float_to_str(f):
def run_and_return_cost_time(chialisp):
start = time.time()
clvm_loop = "((c (q ((c (f (a)) (c (f (a)) (c (f (r (a))) (c (f (r (r (a))))"
" (q ()))))))) (c (q ((c (i (f (r (a))) (q (i (q 1) ((c (f (a)) (c (f (a))"

4
tests/util/build_network_protocol_files.py
View File

@ -150,7 +150,6 @@ def visit_all_messages(visitor: Callable[[Any, str], None]) -> None:
def get_protocol_bytes() -> bytes:
result = b""
def visitor(obj: Any, name: str) -> None:
@ -163,7 +162,6 @@ def get_protocol_bytes() -> bytes:
def build_protocol_test() -> str:
result = """# this file is generated by build_network_protocol_files.py
from typing import Tuple
@ -207,7 +205,6 @@ def test_protocol_bytes() -> None:
def get_protocol_json() -> str:
result = """# this file is generated by build_network_protocol_files.py
from typing import Any, Dict
"""
@ -225,7 +222,6 @@ from typing import Any, Dict
def build_json_test() -> str:
result = """# this file is generated by build_network_protocol_files.py
from tests.util.network_protocol_data import * # noqa: F403

1
tests/util/test_chunks.py
View File

@ -4,7 +4,6 @@ from chia.util.chunks import chunks
def test_chunks() -> None:
assert list(chunks([], 0)) == []
assert list(chunks(["a"], 0)) == [["a"]]
assert list(chunks(["a", "b"], 0)) == [["a"], ["b"]]

1
tests/util/test_full_block_utils.py
View File

@ -246,7 +246,6 @@ def get_full_blocks() -> Iterator[FullBlock]:
@pytest.mark.asyncio
# @pytest.mark.skip("This test is expensive and has already convinced us the parser works")
async def test_parser():
# loop over every combination of Optionals being set and not set
# along with random values for the FullBlock fields. Ensure
# generator_from_block() successfully parses out the generator object

2
tests/util/test_logging_filter.py
View File

@ -11,7 +11,6 @@ from chia.util.logging import TimedDuplicateFilter
def test_logging_filter(caplog: pytest.LogCaptureFixture) -> None:
log_interval_secs = 1
num_logs = 11
sleep_secs = 0.095
@ -32,7 +31,6 @@ def test_logging_filter(caplog: pytest.LogCaptureFixture) -> None:
def test_dont_filter_non_matches(caplog: pytest.LogCaptureFixture) -> None:
log = logging.getLogger()
log.addFilter(TimedDuplicateFilter("Filter this log message.*", 10))

1
tests/util/test_network_protocol_files.py
View File

@ -20,7 +20,6 @@ def parse_blob(input_bytes: bytes) -> Tuple[bytes, bytes]:
def test_protocol_bytes() -> None:
filename: Path = get_network_protocol_filename()
assert filename.exists()
with open(filename, "rb") as f:

1
tests/util/test_network_protocol_test.py
View File

@ -46,7 +46,6 @@ def test_missing_messages_state_machine() -> None:
def test_missing_messages() -> None:
wallet_msgs = {
"CoinState",
"CoinStateUpdate",

1
tests/util/test_struct_stream.py
View File

@ -107,7 +107,6 @@ class TestStructStream:
length: int,
struct_format: Optional[str],
) -> None:
with pytest.raises(ValueError):
t = cls(upper_boundary + 1)

2
tests/wallet/sync/test_wallet_sync.py
View File

@ -582,7 +582,6 @@ class TestWalletSync:
@pytest.mark.asyncio
async def test_get_wp_fork_point(self, default_10000_blocks):
blocks = default_10000_blocks
header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(blocks)
wpf = WeightProofHandler(test_constants, BlockCache(sub_blocks, header_cache, height_to_hash, summaries))
@ -673,7 +672,6 @@ class TestWalletSync:
xch_spam_amount,
dust_value,
):
full_nodes, wallets, _ = two_wallet_nodes_custom_spam_filtering
farm_wallet_node, farm_wallet_server = wallets[0]

2
tests/wallet/test_offer_parsing_performance.py
View File

@ -30,7 +30,6 @@ def enable_profiler(name: str) -> Iterator[None]:
@pytest.mark.benchmark
def test_offer_parsing_performance() -> None:
offer_bytes = bytes.fromhex(test_offer)
with assert_runtime(seconds=2, label="Offer.from_bytes()"):
with enable_profiler("offer-parsing"):
@ -41,7 +40,6 @@ def test_offer_parsing_performance() -> None:
@pytest.mark.benchmark
def test_offered_coins_performance() -> None:
offer_bytes = bytes.fromhex(test_offer)
o = Offer.from_bytes(offer_bytes)
with assert_runtime(seconds=2.5, label="Offer.from_bytes()"):

2
tests/wallet/test_puzzle_store.py
View File

@ -15,9 +15,7 @@ from tests.util.db_connection import DBConnection
class TestPuzzleStore:
@pytest.mark.asyncio
async def test_puzzle_store(self):
async with DBConnection(1) as wrapper:
db = await WalletPuzzleStore.create(wrapper)
derivation_recs = []
# wallet_types = [t for t in WalletType]

2
tests/wallet/test_singleton_lifecycle_fast.py
View File

@ -398,7 +398,6 @@ def assert_coin_spent(coin_store: CoinStore, coin: Coin, is_spent=True):
def spend_coin_to_singleton(
puzzle_db: PuzzleDB, launcher_puzzle: Program, coin_store: CoinStore, now: CoinTimestamp
) -> Tuple[List[Coin], List[CoinSpend]]:
farmed_coin_amount = 100000
metadata = [("foo", "bar")]
@ -471,7 +470,6 @@ def filter_p2_singleton(puzzle_db: PuzzleDB, singleton_wallet: SingletonWallet,
def test_lifecycle_with_coinstore_as_wallet():
PUZZLE_DB = PuzzleDB()
interested_singletons = []

4
tests/wallet/test_wallet_coin_store.py
View File

@ -312,7 +312,6 @@ def record(c: Coin, *, confirmed: int, spent: int) -> WalletCoinRecord:
@pytest.mark.asyncio
async def test_get_coin_names_to_check() -> None:
r1 = record(coin_1, confirmed=1, spent=0)
r2 = record(coin_2, confirmed=2, spent=4)
r3 = record(coin_3, confirmed=3, spent=5)
@ -334,7 +333,6 @@ async def test_get_coin_names_to_check() -> None:
await store.add_coin_record(r7)
for i in range(10):
coins = await store.get_coin_names_to_check(i)
# r1 is unspent and should always be included, regardless of height
@ -355,7 +353,6 @@ async def test_get_coin_names_to_check() -> None:
@pytest.mark.asyncio
async def test_get_first_coin_height() -> None:
r1 = record(coin_1, confirmed=1, spent=0)
r2 = record(coin_2, confirmed=2, spent=4)
r3 = record(coin_3, confirmed=3, spent=5)
@ -381,7 +378,6 @@ async def test_get_first_coin_height() -> None:
@pytest.mark.asyncio
async def test_rollback_to_block() -> None:
r1 = record(coin_1, confirmed=1, spent=0)
r2 = record(coin_2, confirmed=2, spent=4)
r3 = record(coin_3, confirmed=3, spent=5)

1
tools/analyze-chain.py
View File

@ -71,7 +71,6 @@ def callable_for_module_function_path(call: str) -> Callable:
@click.option("--end", default=None, help="last block to examine")
@click.option("--call", default=None, help="function to pass block iterator to in form `module:function`")
def main(file: Path, mempool_mode: bool, start: int, end: Optional[int], call: Optional[str], verify_signatures: bool):
call_f: Callable[[Union[BlockInfo, FullBlock], bytes32, int, List[bytes], float, int], None]
if call is None:
call_f = partial(default_call, verify_signatures)

2
tools/analyze_memory_profile.py
View File

@ -162,7 +162,6 @@ def analyze_slot(ctx: click.Context, slot: int) -> None:
filter_frames = set()
for name, fr in all_frames.items():
# frames that are less than 0.1% of the total allocations are
# filtered
if fr.size / total_size < 0.001:
@ -181,7 +180,6 @@ def analyze_slot(ctx: click.Context, slot: int) -> None:
# print all edges (calls)
for name, fr in all_frames.items():
if name in filter_frames:
continue

1
tools/cpu_utilization.py
View File

@ -38,7 +38,6 @@ def main(pid: int, output: str, threads: bool) -> None:
try:
step = 0
while process.is_running():
timestamps.append(time.perf_counter())
ps = process.cpu_times()
stats[pid][step] = Counters(ps.user, ps.system)

3
tools/generate_chain.py
View File

@ -55,7 +55,6 @@ def enable_profiler(profile: bool, counter: int) -> Iterator[None]:
"--output", type=str, required=False, default=None, help="the filename to write the resulting sqlite database to"
)
def main(length: int, fill_rate: int, profile: bool, block_refs: bool, output: Optional[str]) -> None:
if fill_rate < 0 or fill_rate > 100:
print("fill-rate must be within [0, 100]")
sys.exit(1)
@ -79,7 +78,6 @@ def main(length: int, fill_rate: int, profile: bool, block_refs: bool, output: O
root_path = Path("./test-chain").resolve()
root_path.mkdir(parents=True, exist_ok=True)
with TempKeyring() as keychain:
bt = create_block_tools(constants=test_constants, root_path=root_path, keychain=keychain)
initialize_logging(
"generate_chain", {"log_level": "DEBUG", "log_stdout": False, "log_syslog": False}, root_path=root_path
@ -87,7 +85,6 @@ def main(length: int, fill_rate: int, profile: bool, block_refs: bool, output: O
print(f"writing blockchain to {output}")
with closing(sqlite3.connect(output)) as db:
db.execute(
"CREATE TABLE full_blocks("
"header_hash blob PRIMARY KEY,"

2
tools/run_block.py
View File

@ -103,7 +103,6 @@ def npc_to_dict(npc: NPC):
def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants, max_cost: int) -> List[CAT]:
block_args = [bytes(a) for a in block_generator.generator_refs]
cost, block_result = block_generator.program.run_with_cost(max_cost, DESERIALIZE_MOD, block_args)
@ -111,7 +110,6 @@ def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants
cat_list: List[CAT] = []
for spend in coin_spends.as_iter():
parent, puzzle, amount, solution = spend.as_iter()
args = match_cat_puzzle(uncurry_puzzle(puzzle))

3
tools/test_full_sync.py
View File

@ -107,7 +107,6 @@ async def run_sync_test(
node_profiler: bool,
start_at_checkpoint: Optional[str],
) -> None:
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
handler = logging.FileHandler("test-full-sync.log")
@ -122,7 +121,6 @@ async def run_sync_test(
logger.addHandler(check_log)
with tempfile.TemporaryDirectory() as root_dir:
root_path = Path(root_dir)
if start_at_checkpoint is not None:
shutil.copytree(Path(start_at_checkpoint) / ".", root_path, dirs_exist_ok=True)
@ -332,7 +330,6 @@ async def run_sync_checkpoint(
root_path: Path,
max_height: int,
) -> None:
root_path.mkdir(parents=True, exist_ok=True)
chia_init(root_path, should_check_keys=False, v1_db=False)