async def add_spendbundle(
self, new_spend: SpendBundle, to_pool: Mempool = None
) -> Tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]:
"""
Tries to add spendbundle to either self.mempools or to_pool if it's specified.
Returns true if it's added in any of pools, Returns error if it fails.
"""
self.seen_bundle_hashes[new_spend.name()] = new_spend.name()
self.maybe_pop_seen()
# Calculate the cost and fees
program = best_solution_program(new_spend)
# npc contains names of the coins removed, puzzle_hashes and their spend conditions
fail_reason, npc_list, cost = calculate_cost_of_program(
program, self.constants.CLVM_COST_RATIO_CONSTANT,
)
if fail_reason:
return None, MempoolInclusionStatus.FAILED, fail_reason
# build removal list
removal_names: List[bytes32] = new_spend.removal_names()
additions = new_spend.additions()
additions_dict: Dict[bytes32, Coin] = {}
for add in additions:
additions_dict[add.name()] = add
addition_amount = uint64(0)
# Check additions for max coin amount
for coin in additions:
if coin.amount >= uint64.from_bytes(self.constants["MAX_COIN_AMOUNT"]):
return (
None,
MempoolInclusionStatus.FAILED,
Err.COIN_AMOUNT_EXCEEDS_MAXIMUM,
)
addition_amount = uint64(addition_amount + coin.amount)
# Check for duplicate outputs
addition_counter = collections.Counter(_.name() for _ in additions)
for k, v in addition_counter.items():
if v > 1:
return None, MempoolInclusionStatus.FAILED, Err.DUPLICATE_OUTPUT
# Check for duplicate inputs
removal_counter = collections.Counter(name for name in removal_names)
for k, v in removal_counter.items():
if v > 1:
return None, MempoolInclusionStatus.FAILED, Err.DOUBLE_SPEND
# Spend might be valid for one pool but not for other
added_count = 0
errors: List[Err] = []
targets: List[Mempool]
# If the transaction is added to potential set (to be retried), this is set.
added_to_potential: bool = False
potential_error: Optional[Err] = None
if to_pool is not None:
targets = [to_pool]
else:
targets = list(self.mempools.values())
for pool in targets:
# Skip if already added
if new_spend.name() in pool.spends:
added_count += 1
continue
removal_record_dict: Dict[bytes32, CoinRecord] = {}
removal_coin_dict: Dict[bytes32, Coin] = {}
unknown_unspent_error: bool = False
removal_amount = uint64(0)
for name in removal_names:
removal_record = await self.coin_store.get_coin_record(
name, pool.header
)
if removal_record is None and name not in additions_dict:
unknown_unspent_error = True
break
elif name in additions_dict:
removal_coin = additions_dict[name]
removal_record = CoinRecord(
removal_coin,
uint32(pool.header.height + 1),
uint32(0),
False,
False,
)
assert removal_record is not None
removal_amount = uint64(removal_amount + removal_record.coin.amount)
removal_record_dict[name] = removal_record
removal_coin_dict[name] = removal_record.coin
if unknown_unspent_error:
errors.append(Err.UNKNOWN_UNSPENT)
continue
if addition_amount > removal_amount:
return None, MempoolInclusionStatus.FAILED, Err.MINTING_COIN
fees = removal_amount - addition_amount
assert_fee_sum: uint64 = uint64(0)
for npc in npc_list:
if ConditionOpcode.ASSERT_FEE in npc.condition_dict:
fee_list: List[ConditionVarPair] = npc.condition_dict[
ConditionOpcode.ASSERT_FEE
]
for cvp in fee_list:
fee = int_from_bytes(cvp.var1)
assert_fee_sum = assert_fee_sum + fee
if fees < assert_fee_sum:
return (
None,
MempoolInclusionStatus.FAILED,
Err.ASSERT_FEE_CONDITION_FAILED,
)
if cost == 0:
return None, MempoolInclusionStatus.FAILED, Err.UNKNOWN
fees_per_cost: float = fees / cost
# If pool is at capacity check the fee, if not then accept even without the fee
if pool.at_full_capacity():
if fees == 0:
errors.append(Err.INVALID_FEE_LOW_FEE)
continue
if fees_per_cost < pool.get_min_fee_rate():
errors.append(Err.INVALID_FEE_LOW_FEE)
continue
# Check removals against UnspentDB + DiffStore + Mempool + SpendBundle
# Use this information later when constructing a block
fail_reason, conflicts = await self.check_removals(
removal_record_dict, pool
)
# If there is a mempool conflict check if this spendbundle has a higher fee per cost than all others
tmp_error: Optional[Err] = None
conflicting_pool_items: Dict[bytes32, MempoolItem] = {}
if fail_reason is Err.MEMPOOL_CONFLICT:
for conflicting in conflicts:
sb: MempoolItem = pool.removals[conflicting.name()]
conflicting_pool_items[sb.name] = sb
for item in conflicting_pool_items.values():
if item.fee_per_cost >= fees_per_cost:
tmp_error = Err.MEMPOOL_CONFLICT
self.add_to_potential_tx_set(new_spend)
added_to_potential = True
potential_error = Err.MEMPOOL_CONFLICT
break
elif fail_reason:
errors.append(fail_reason)
continue
if tmp_error:
errors.append(tmp_error)
continue
# Verify conditions, create hash_key list for aggsig check
pks: List[G1Element] = []
msgs: List[G2Element] = []
error: Optional[Err] = None
for npc in npc_list:
coin_record: CoinRecord = removal_record_dict[npc.coin_name]
# Check that the revealed removal puzzles actually match the puzzle hash
if npc.puzzle_hash != coin_record.coin.puzzle_hash:
log.warning(
"Mempool rejecting transaction because of wrong puzzle_hash"
)
log.warning(f"{npc.puzzle_hash} != {coin_record.coin.puzzle_hash}")
return None, MempoolInclusionStatus.FAILED, Err.WRONG_PUZZLE_HASH
error = mempool_check_conditions_dict(
coin_record, new_spend, npc.condition_dict, pool
)
if error:
if (
error is Err.ASSERT_BLOCK_INDEX_EXCEEDS_FAILED
or error is Err.ASSERT_BLOCK_AGE_EXCEEDS_FAILED
):
self.add_to_potential_tx_set(new_spend)
added_to_potential = True
potential_error = error
break
for pk, m in pkm_pairs_for_conditions_dict(
npc.condition_dict, npc.coin_name
):
pks.append(pk)
msgs.append(m)
if error:
errors.append(error)
continue
# Verify aggregated signature
validates = AugSchemeMPL.agg_verify(
pks, msgs, new_spend.aggregated_signature
)
if not validates:
return None, MempoolInclusionStatus.FAILED, Err.BAD_AGGREGATE_SIGNATURE
# Remove all conflicting Coins and SpendBundles
if fail_reason:
mitem: MempoolItem
for mitem in conflicting_pool_items.values():
pool.remove_spend(mitem)
new_item = MempoolItem(new_spend, fees_per_cost, uint64(fees), uint64(cost))
pool.add_to_pool(new_item, additions, removal_coin_dict)
added_count += 1
if added_count > 0:
return uint64(cost), MempoolInclusionStatus.SUCCESS, None
elif added_to_potential:
return uint64(cost), MempoolInclusionStatus.PENDING, potential_error
else:
return None, MempoolInclusionStatus.FAILED, errors[0]
async def _validate_transactions(
self, block: FullBlock, fee_base: uint64
) -> Optional[Err]:
# TODO(straya): review, further test the code, and number all the validation steps
# 1. Check that transactions generator is present
if not block.transactions_generator:
return Err.UNKNOWN
# Get List of names removed, puzzles hashes for removed coins and conditions crated
error, npc_list, cost = calculate_cost_of_program(
block.transactions_generator, self.constants["CLVM_COST_RATIO_CONSTANT"]
)
# 2. Check that cost <= MAX_BLOCK_COST_CLVM
if cost > self.constants["MAX_BLOCK_COST_CLVM"]:
return Err.BLOCK_COST_EXCEEDS_MAX
if error:
return error
prev_header: Header
if block.prev_header_hash in self.headers:
prev_header = self.headers[block.prev_header_hash]
else:
return Err.EXTENDS_UNKNOWN_BLOCK
removals: List[bytes32] = []
removals_puzzle_dic: Dict[bytes32, bytes32] = {}
for npc in npc_list:
removals.append(npc.coin_name)
removals_puzzle_dic[npc.coin_name] = npc.puzzle_hash
additions: List[Coin] = additions_for_npc(npc_list)
additions_dic: Dict[bytes32, Coin] = {}
# Check additions for max coin amount
for coin in additions:
additions_dic[coin.name()] = coin
if coin.amount >= uint64.from_bytes(self.constants["MAX_COIN_AMOUNT"]):
return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM
# Validate addition and removal roots
root_error = self._validate_merkle_root(block, additions, removals)
if root_error:
return root_error
# Validate filter
byte_array_tx: List[bytes32] = []
for coin in additions:
byte_array_tx.append(bytearray(coin.puzzle_hash))
for coin_name in removals:
byte_array_tx.append(bytearray(coin_name))
byte_array_tx.append(bytearray(block.header.data.farmer_rewards_puzzle_hash))
byte_array_tx.append(bytearray(block.header.data.pool_target.puzzle_hash))
bip158: PyBIP158 = PyBIP158(byte_array_tx)
encoded_filter = bytes(bip158.GetEncoded())
filter_hash = std_hash(encoded_filter)
if filter_hash != block.header.data.filter_hash:
return Err.INVALID_TRANSACTIONS_FILTER_HASH
# Watch out for duplicate outputs
addition_counter = collections.Counter(_.name() for _ in additions)
for k, v in addition_counter.items():
if v > 1:
return Err.DUPLICATE_OUTPUT
# Check for duplicate spends inside block
removal_counter = collections.Counter(removals)
for k, v in removal_counter.items():
if v > 1:
return Err.DOUBLE_SPEND
# Check if removals exist and were not previously spend. (unspent_db + diff_store + this_block)
fork_h = find_fork_point_in_chain(self.headers, self.lca_block, block.header)
# Get additions and removals since (after) fork_h but not including this block
additions_since_fork: Dict[bytes32, Tuple[Coin, uint32]] = {}
removals_since_fork: Set[bytes32] = set()
coinbases_since_fork: Dict[bytes32, uint32] = {}
curr: Optional[FullBlock] = await self.block_store.get_block(
block.prev_header_hash
)
assert curr is not None
while curr.height > fork_h:
removals_in_curr, additions_in_curr = await curr.tx_removals_and_additions()
for c_name in removals_in_curr:
removals_since_fork.add(c_name)
for c in additions_in_curr:
additions_since_fork[c.name()] = (c, curr.height)
coinbase_coin = curr.get_coinbase()
fees_coin = curr.get_fees_coin()
additions_since_fork[coinbase_coin.name()] = (
coinbase_coin,
curr.height,
)
additions_since_fork[fees_coin.name()] = (
fees_coin,
curr.height,
)
coinbases_since_fork[coinbase_coin.name()] = curr.height
coinbases_since_fork[fees_coin.name()] = curr.height
curr = await self.block_store.get_block(curr.prev_header_hash)
assert curr is not None
removal_coin_records: Dict[bytes32, CoinRecord] = {}
for rem in removals:
if rem in additions_dic:
# Ephemeral coin
rem_coin: Coin = additions_dic[rem]
new_unspent: CoinRecord = CoinRecord(
rem_coin, block.height, uint32(0), False, False
)
removal_coin_records[new_unspent.name] = new_unspent
else:
assert prev_header is not None
unspent = await self.coin_store.get_coin_record(rem, prev_header)
if unspent is not None and unspent.confirmed_block_index <= fork_h:
# Spending something in the current chain, confirmed before fork
# (We ignore all coins confirmed after fork)
if unspent.spent == 1 and unspent.spent_block_index <= fork_h:
# Spend in an ancestor block, so this is a double spend
return Err.DOUBLE_SPEND
# If it's a coinbase, check that it's not frozen
if unspent.coinbase == 1:
if (
block.height
< unspent.confirmed_block_index + self.coinbase_freeze
):
return Err.COINBASE_NOT_YET_SPENDABLE
removal_coin_records[unspent.name] = unspent
else:
# This coin is not in the current heaviest chain, so it must be in the fork
if rem not in additions_since_fork:
# This coin does not exist in the fork
return Err.UNKNOWN_UNSPENT
if rem in coinbases_since_fork:
# This coin is a coinbase coin
if (
block.height
< coinbases_since_fork[rem] + self.coinbase_freeze
):
return Err.COINBASE_NOT_YET_SPENDABLE
new_coin, confirmed_height = additions_since_fork[rem]
new_coin_record: CoinRecord = CoinRecord(
new_coin,
confirmed_height,
uint32(0),
False,
(rem in coinbases_since_fork),
)
removal_coin_records[new_coin_record.name] = new_coin_record
# This check applies to both coins created before fork (pulled from coin_store),
# and coins created after fork (additions_since_fork)>
if rem in removals_since_fork:
# This coin was spent in the fork
return Err.DOUBLE_SPEND
# Check fees
removed = 0
for unspent in removal_coin_records.values():
removed += unspent.coin.amount
added = 0
for coin in additions:
added += coin.amount
if removed < added:
return Err.MINTING_COIN
fees = removed - added
assert_fee_sum: uint64 = uint64(0)
for npc in npc_list:
if ConditionOpcode.ASSERT_FEE in npc.condition_dict:
fee_list: List[ConditionVarPair] = npc.condition_dict[
ConditionOpcode.ASSERT_FEE
]
for cvp in fee_list:
fee = int_from_bytes(cvp.var1)
assert_fee_sum = assert_fee_sum + fee
if fees < assert_fee_sum:
return Err.ASSERT_FEE_CONDITION_FAILED
# Check coinbase reward
if fees + fee_base != block.header.data.total_transaction_fees:
return Err.BAD_COINBASE_REWARD
# Verify that removed coin puzzle_hashes match with calculated puzzle_hashes
for unspent in removal_coin_records.values():
if unspent.coin.puzzle_hash != removals_puzzle_dic[unspent.name]:
return Err.WRONG_PUZZLE_HASH
# Verify conditions, create hash_key list for aggsig check
pool_target_m = bytes(block.header.data.pool_target)
# The pool signature on the pool target is checked here as well, since the pool signature is
# aggregated along with the transaction signatures
pairs_pks = [block.proof_of_space.pool_public_key]
pairs_msgs = [pool_target_m]
for npc in npc_list:
unspent = removal_coin_records[npc.coin_name]
error = blockchain_check_conditions_dict(
unspent, removal_coin_records, npc.condition_dict, block.header,
)
if error:
return error
for pk, m in pkm_pairs_for_conditions_dict(
npc.condition_dict, npc.coin_name
):
pairs_pks.append(pk)
pairs_msgs.append(m)
# Verify aggregated signature
# TODO: move this to pre_validate_blocks_multiprocessing so we can sync faster
if not block.header.data.aggregated_signature:
return Err.BAD_AGGREGATE_SIGNATURE
validates = AugSchemeMPL.agg_verify(
pairs_pks, pairs_msgs, block.header.data.aggregated_signature
)
if not validates:
return Err.BAD_AGGREGATE_SIGNATURE
return None
