async def get_all_transactions(self,
wallet_id: int,
type: int = None
) -> List[TransactionRecord]:
"""
Returns all stored transactions.
"""
if type is None:
cursor = await self.db_connection.execute(
"SELECT * from transaction_record where wallet_id=?",
(wallet_id, ))
else:
cursor = await self.db_connection.execute(
"SELECT * from transaction_record where wallet_id=? and type=?",
(
wallet_id,
type,
),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
cache_set = set()
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
cache_set.add(record.name)
if wallet_id not in self.tx_wallet_cache:
self.tx_wallet_cache[wallet_id] = {}
self.tx_wallet_cache[wallet_id][type] = cache_set
return records
async def get_not_sent(self) -> List[TransactionRecord]:
"""
Returns the list of transaction that have not been received by full node yet.
"""
current_time = int(time.time())
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE confirmed=?",
(0, ),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
if record.name in self.tx_submitted:
time_submitted, count = self.tx_submitted[record.name]
if time_submitted < current_time - (60 * 10):
records.append(record)
self.tx_submitted[record.name] = current_time, 1
else:
if count < 5:
records.append(record)
self.tx_submitted[record.name] = time_submitted, (
count + 1)
else:
records.append(record)
self.tx_submitted[record.name] = current_time, 1
return records
async def get_unconfirmed_for_wallet(
self, wallet_id: int) -> List[TransactionRecord]:
"""
Returns the list of transaction that have not yet been confirmed.
"""
if wallet_id in self.unconfirmed_for_wallet:
return list(self.unconfirmed_for_wallet[wallet_id].values())
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE confirmed=? and wallet_id=?",
(
0,
wallet_id,
),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
dict = {}
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
dict[record.name] = record
self.unconfirmed_for_wallet[wallet_id] = dict
return records
async def get_transactions_by_trade_id(
self, trade_id: bytes32) -> List[TransactionRecord]:
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE trade_id=?", (trade_id, ))
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_all_transactions(self) -> List[TransactionRecord]:
"""
Returns all stored transactions.
"""
cursor = await self.db_connection.execute(
"SELECT * from transaction_record")
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_transaction_above(self, height: int) -> List[TransactionRecord]:
# Can be -1 (get all tx)
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE confirmed_at_height>?", (height,)
)
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_all_unconfirmed(self) -> List[TransactionRecord]:
"""
Returns the list of all transaction that have not yet been confirmed.
"""
cursor = await self.db_connection.execute("SELECT * from transaction_record WHERE confirmed=?", (0,))
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_transaction_record(self, tx_id: bytes32) -> Optional[TransactionRecord]:
"""
Checks DB and cache for TransactionRecord with id: id and returns it.
"""
if tx_id in self.tx_record_cache:
return self.tx_record_cache[tx_id]
# NOTE: bundle_id is being stored as bytes, not hex
cursor = await self.db_connection.execute("SELECT * from transaction_record WHERE bundle_id=?", (tx_id,))
row = await cursor.fetchone()
await cursor.close()
if row is not None:
record = TransactionRecord.from_bytes(row[0])
return record
return None
async def get_farming_rewards(self):
"""
Returns the list of all farming rewards.
"""
fee_int = TransactionType.FEE_REWARD.value
pool_int = TransactionType.COINBASE_REWARD.value
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE confirmed=? and (type=? or type=?)",
(1, fee_int, pool_int))
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_not_sent(self) -> List[TransactionRecord]:
"""
Returns the list of transaction that have not been received by full node yet.
"""
cursor = await self.db_connection.execute(
"SELECT * from transaction_record WHERE sent<? and confirmed=?",
(
4,
0,
),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records
async def get_transactions_between(self, wallet_id: int, start, end) -> List[TransactionRecord]:
"""Return a list of transaction between start and end index. List is in reverse chronological order.
start = 0 is most recent transaction
"""
limit = end - start
cursor = await self.db_connection.execute(
f"SELECT * from transaction_record where wallet_id=? and confirmed_at_height not in"
f" (select confirmed_at_height from transaction_record order by confirmed_at_height"
f" ASC LIMIT {start})"
f" order by confirmed_at_height DESC LIMIT {limit}",
(wallet_id,),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
records.reverse()
return records
async def get_transactions_between(self,
wallet_id: int,
start,
end,
sort_key=None,
reverse=False
) -> List[TransactionRecord]:
"""Return a list of transaction between start and end index. List is in reverse chronological order.
start = 0 is most recent transaction
"""
limit = end - start
if sort_key is None:
sort_key = "CONFIRMED_AT_HEIGHT"
if sort_key not in SortKey.__members__:
raise ValueError(f"There is no known sort {sort_key}")
if reverse:
query_str = SortKey[sort_key].descending()
else:
query_str = SortKey[sort_key].ascending()
cursor = await self.db_connection.execute(
f"SELECT * from transaction_record where wallet_id=?"
f" {query_str}, rowid"
f" LIMIT {start}, {limit}",
(wallet_id, ),
)
rows = await cursor.fetchall()
await cursor.close()
records = []
for row in rows:
record = TransactionRecord.from_bytes(row[0])
records.append(record)
return records