async def get_unspent_coins_for_wallet(
self, wallet_id: int) -> Set[WalletCoinRecord]:
""" Returns set of CoinRecords that have not been spent yet for a wallet. """
async with self.wallet_cache_lock:
if wallet_id in self.coin_wallet_record_cache:
wallet_coins: Dict[
bytes32, WalletCoinRecord] = self.coin_wallet_record_cache[
wallet_id]
return set(wallet_coins.values())
coin_set = set()
cursor = await self.db_connection.execute(
"SELECT * from coin_record WHERE spent=0 and wallet_id=?",
(wallet_id, ),
)
rows = await cursor.fetchall()
await cursor.close()
cache_dict = {}
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coin_record = WalletCoinRecord(coin, row[1], row[2],
row[3], row[4],
WalletType(row[8]), row[9])
coin_set.add(coin_record)
cache_dict[coin.name()] = coin_record
self.coin_wallet_record_cache[wallet_id] = cache_dict
return coin_set
async def get_coin_records_by_puzzle_hashes(
self,
include_spent_coins: bool,
puzzle_hashes: List[bytes32],
start_height: uint32 = uint32(0),
end_height: uint32 = uint32((2**32) - 1),
) -> List[CoinRecord]:
if len(puzzle_hashes) == 0:
return []
coins = set()
puzzle_hashes_db = tuple([ph.hex() for ph in puzzle_hashes])
cursor = await self.coin_record_db.execute(
f'SELECT * from coin_record WHERE puzzle_hash in ({"?," * (len(puzzle_hashes_db) - 1)}?) '
f"AND confirmed_index>=? AND confirmed_index<? "
f"{'' if include_spent_coins else 'AND spent=0'}",
puzzle_hashes_db + (start_height, end_height),
)
rows = await cursor.fetchall()
await cursor.close()
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8]))
return list(coins)
async def get_coin_record_by_coin_id(self, coin_id: bytes32) -> Optional[WalletCoinRecord]:
"""Returns a coin records with the given name, if it exists"""
cursor = await self.db_connection.execute("SELECT * from coin_record WHERE coin_name=?", (coin_id.hex(),))
row = await cursor.fetchone()
await cursor.close()
if row is None:
return None
coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7]))
coin_record = WalletCoinRecord(coin, row[1], row[2], row[3], row[4], WalletType(row[8]), row[9])
return coin_record
async def all_non_reward_coins(self) -> List[Coin]:
coins = set()
cursor = await self.mempool_manager.coin_store.coin_record_db.execute(
"SELECT * from coin_record WHERE coinbase=0 AND spent=0 ", )
rows = await cursor.fetchall()
await cursor.close()
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.add(coin)
return list(coins)
async def get_coins_added_at_height(self,
height: uint32) -> List[CoinRecord]:
cursor = await self.coin_record_db.execute(
"SELECT * from coin_record WHERE confirmed_index=?", (height, ))
rows = await cursor.fetchall()
await cursor.close()
coins = []
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.append(
CoinRecord(coin, row[1], row[2], row[3], row[4], row[8]))
return coins
async def get_coin_record(self,
coin_name: bytes32) -> Optional[CoinRecord]:
if coin_name.hex() in self.coin_record_cache:
return self.coin_record_cache[coin_name.hex()]
cursor = await self.coin_record_db.execute(
"SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(), ))
row = await cursor.fetchone()
await cursor.close()
if row is not None:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
return CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])
return None
async def get_all_coins(self) -> Set[WalletCoinRecord]:
""" Returns set of all CoinRecords."""
coins = set()
cursor = await self.db_connection.execute("SELECT * from coin_record")
rows = await cursor.fetchall()
await cursor.close()
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.add(
WalletCoinRecord(coin, row[1], row[2], row[3], row[4],
WalletType(row[8]), row[9]))
return coins
async def get_coin_record(
self, coin_name: bytes32) -> Optional[WalletCoinRecord]:
""" Returns CoinRecord with specified coin id. """
if coin_name in self.coin_record_cache:
return self.coin_record_cache[coin_name]
cursor = await self.db_connection.execute(
"SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(), ))
row = await cursor.fetchone()
await cursor.close()
if row is not None:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
return WalletCoinRecord(coin, row[1], row[2], row[3], row[4],
WalletType(row[8]), row[9])
return None
async def get_coin_record(self,
coin_name: bytes32) -> Optional[CoinRecord]:
cached = self.coin_record_cache.get(coin_name)
if cached is not None:
return cached
cursor = await self.coin_record_db.execute(
"SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(), ))
row = await cursor.fetchone()
await cursor.close()
if row is not None:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
record = CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])
self.coin_record_cache.put(record.coin.name(), record)
return record
return None
async def get_coin_records_by_puzzle_hash(
self, puzzle_hash: bytes32) -> List[WalletCoinRecord]:
"""Returns a list of all coin records with the given puzzle hash"""
coins = set()
cursor = await self.db_connection.execute(
"SELECT * from coin_record WHERE puzzle_hash=?",
(puzzle_hash.hex(), ))
rows = await cursor.fetchall()
await cursor.close()
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.add(
WalletCoinRecord(coin, row[1], row[2], row[3], row[4],
WalletType(row[8]), row[9]))
return list(coins)
async def get_coin_records_by_puzzle_hash(
self,
include_spent_coins: bool,
puzzle_hash: bytes32,
start_height: uint32 = uint32(0),
end_height: uint32 = uint32((2**32) - 1),
) -> List[CoinRecord]:
coins = set()
cursor = await self.coin_record_db.execute(
f"SELECT * from coin_record WHERE puzzle_hash=? AND confirmed_index>=? AND confirmed_index<? "
f"{'' if include_spent_coins else 'AND spent=0'}",
(puzzle_hash.hex(), start_height, end_height),
)
rows = await cursor.fetchall()
await cursor.close()
for row in rows:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])),
uint64.from_bytes(row[7]))
coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8]))
return list(coins)
def coin_record_from_row(self, row: sqlite3.Row) -> WalletCoinRecord:
coin = Coin(bytes32(bytes.fromhex(row[6])),
bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7]))
return WalletCoinRecord(coin, uint32(row[1]), uint32(row[2]),
bool(row[3]), bool(row[4]), WalletType(row[8]),
row[9])
def row_to_coin(self, row) -> Coin:
return Coin(bytes32(self.maybe_from_hex(row[4])),
bytes32(self.maybe_from_hex(row[3])),
uint64.from_bytes(row[5]))
