async def send_transaction_multi(
self,
wallet_id: str,
additions: List[Dict],
coins: List[Coin] = None,
fee: uint64 = uint64(0)) -> TransactionRecord:
# Converts bytes to hex for puzzle hashes
additions_hex = []
for ad in additions:
additions_hex.append({
"amount": ad["amount"],
"puzzle_hash": ad["puzzle_hash"].hex()
})
if "memos" in ad:
additions_hex[-1]["memos"] = ad["memos"]
if coins is not None and len(coins) > 0:
coins_json = [c.to_json_dict() for c in coins]
response: Dict = await self.fetch(
"send_transaction_multi",
{
"wallet_id": wallet_id,
"additions": additions_hex,
"coins": coins_json,
"fee": fee
},
)
else:
response = await self.fetch("send_transaction_multi", {
"wallet_id": wallet_id,
"additions": additions_hex,
"fee": fee
})
return TransactionRecord.from_json_dict_convenience(
response["transaction"])
async def get_transactions(
self,
wallet_id: str,
start: int = None,
end: int = None,
sort_key: SortKey = None,
reverse: bool = False,
) -> List[TransactionRecord]:
request: Dict[str, Any] = {"wallet_id": wallet_id}
if start is not None:
request["start"] = start
if end is not None:
request["end"] = end
if sort_key is not None:
request["sort_key"] = sort_key.name
request["reverse"] = reverse
res = await self.fetch(
"get_transactions",
request,
)
return [
TransactionRecord.from_json_dict_convenience(tx)
for tx in res["transactions"]
]
async def get_transaction(self, wallet_id: str,
transaction_id: bytes32) -> TransactionRecord:
res = await self.fetch(
"get_transaction",
{
"walled_id": wallet_id,
"transaction_id": transaction_id.hex()
},
)
return TransactionRecord.from_json_dict_convenience(res["transaction"])
async def is_transaction_confirmed(user_wallet_id, api,
tx_id: bytes32) -> bool:
try:
val = await api.get_transaction({
"wallet_id": user_wallet_id,
"transaction_id": tx_id.hex()
})
except ValueError:
return False
return TransactionRecord.from_json_dict_convenience(
val["transaction"]).confirmed
async def create_signed_transaction(
self,
additions: List[Dict],
coins: List[Coin] = None,
fee: uint64 = uint64(0),
coin_announcements: Optional[List[Announcement]] = None,
puzzle_announcements: Optional[List[Announcement]] = None,
) -> TransactionRecord:
# Converts bytes to hex for puzzle hashes
additions_hex = []
for ad in additions:
additions_hex.append({
"amount": ad["amount"],
"puzzle_hash": ad["puzzle_hash"].hex()
})
if "memos" in ad:
additions_hex[-1]["memos"] = ad["memos"]
request: Dict[str, Any] = {
"additions": additions_hex,
"fee": fee,
}
if coin_announcements is not None and len(coin_announcements) > 0:
request["coin_announcements"] = [{
"coin_id":
ann.origin_info.hex(),
"message":
ann.message.hex(),
"morph_bytes":
ann.morph_bytes.hex()
if ann.morph_bytes is not None else b"".hex(),
} for ann in coin_announcements]
if puzzle_announcements is not None and len(puzzle_announcements) > 0:
request["puzzle_announcements"] = [{
"puzzle_hash":
ann.origin_info.hex(),
"message":
ann.message.hex(),
"morph_bytes":
ann.morph_bytes.hex()
if ann.morph_bytes is not None else b"".hex(),
} for ann in puzzle_announcements]
if coins is not None and len(coins) > 0:
coins_json = [c.to_json_dict() for c in coins]
request["coins"] = coins_json
response: Dict = await self.fetch("create_signed_transaction", request)
return TransactionRecord.from_json_dict_convenience(
response["signed_tx"])
async def is_transaction_in_mempool(user_wallet_id, api,
tx_id: bytes32) -> bool:
try:
val = await api.get_transaction({
"wallet_id": user_wallet_id,
"transaction_id": tx_id.hex()
})
except ValueError:
return False
for _, mis, _ in TransactionRecord.from_json_dict_convenience(
val["transaction"]).sent_to:
if (MempoolInclusionStatus(mis) == MempoolInclusionStatus.SUCCESS or
MempoolInclusionStatus(mis) == MempoolInclusionStatus.PENDING):
return True
return False
async def cat_spend(
self,
wallet_id: str,
amount: uint64,
inner_address: str,
fee: uint64 = uint64(0),
memos: Optional[List[str]] = None,
) -> TransactionRecord:
send_dict = {
"wallet_id": wallet_id,
"amount": amount,
"inner_address": inner_address,
"fee": fee,
"memos": memos if memos else [],
}
res = await self.fetch("cat_spend", send_dict)
return TransactionRecord.from_json_dict_convenience(res["transaction"])
async def send_transaction(
self,
wallet_id: str,
amount: uint64,
address: str,
fee: uint64 = uint64(0),
memos: Optional[List[str]] = None) -> TransactionRecord:
if memos is None:
send_dict: Dict = {
"wallet_id": wallet_id,
"amount": amount,
"address": address,
"fee": fee
}
else:
send_dict = {
"wallet_id": wallet_id,
"amount": amount,
"address": address,
"fee": fee,
"memos": memos,
}
res = await self.fetch("send_transaction", send_dict)
return TransactionRecord.from_json_dict_convenience(res["transaction"])
