def post(self):
try:
tx_params = request.json
user = self.user
account_id = user.account_id
currency = DiemCurrency[tx_params["currency"]]
amount = int(tx_params["amount"])
recv_address: str = tx_params["receiver_address"]
dest_address, dest_subaddress = identifier.decode_account(
recv_address,
context.get().config.diem_address_hrp())
tx = transaction_service.send_transaction(
sender_id=account_id,
amount=amount,
currency=currency,
destination_address=utils.account_address_bytes(
dest_address).hex(),
destination_subaddress=dest_subaddress.hex()
if dest_subaddress else None,
)
transaction = AccountRoutes.get_transaction_response_object(
user.account_id, tx)
return transaction, HTTPStatus.OK
except transaction_service.RiskCheckError as risk_check_failed_error:
return self.respond_with_error(HTTPStatus.FAILED_DEPENDENCY,
str(risk_check_failed_error))
except transaction_service.SelfAsDestinationError as send_to_self_error:
return self.respond_with_error(HTTPStatus.FORBIDDEN,
str(send_to_self_error))
def mint(
self,
authkey_hex: str,
amount: int,
identifier: str,
session: Optional[requests.Session] = None,
timeout: Optional[Union[float, Tuple[float, float]]] = None,
) -> int:
dd_address_hex = account_address_hex(DESIGNATED_DEALER_ADDRESS)
account = BlockchainMock.get_account_resource(dd_address_hex)
sequence = account.sequence_number
version = BlockchainMock.blockchain.version
decoded_addr, decoded_subaddr = decode_account(authkey_hex)
metadata = general_metadata(to_subaddress=decoded_subaddr)
address_hex_bytes = account_address_bytes(decoded_addr)
process_incoming_transaction(
sender_address=dd_address_hex,
receiver_address=authkey_hex,
sequence=sequence,
amount=amount,
currency=DiemCurrency.Coin1,
metadata=metadata,
)
BlockchainMock.blockchain.version += 1
tx = MockSignedTransaction(
sender=bytes.fromhex(ASSOC_AUTHKEY),
amount=amount,
currency=identifier,
receiver=address_hex_bytes,
metadata=metadata,
sequence=account.sequence_number,
version=version,
)
account.sequence_number += 1
account.transactions[sequence] = tx
BlockchainMock.blockchain.transactions[version] = tx
return sequence
else:
# use DD private key to send P2P transaction to the watched account
sender_account = LocalAccount(
Ed25519PrivateKey.from_private_bytes(
bytes.fromhex(private_key)))
sender_account_info = diem_client.get_account(
sender_account.account_address)
sender_account_addr_hex = utils.account_address_hex(
sender_account.account_address)
script = stdlib.encode_peer_to_peer_with_metadata_script(
currency=utils.currency_code(currency),
payee=watched_account_addr,
amount=refill_amount,
metadata=txnmetadata.general_metadata(
from_subaddress=utils.account_address_bytes(
sender_account.account_address),
to_subaddress=utils.account_address_bytes(
watched_account_addr),
),
metadata_signature=b"",
)
raw_tx = diem_types.RawTransaction(
sender=sender_account.account_address,
sequence_number=sender_account_info.sequence_number,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time()) + 30,
chain_id=diem_types.ChainId.from_int(network_chainid),
)