def submit_transaction(
transaction: Transaction,
client: Client,
) -> Response:
"""
Submits a transaction to the ledger.
Args:
transaction: the Transaction to be submitted.
client: the network client with which to submit the transaction.
Returns:
The response from the ledger.
Raises:
XRPLRequestFailureException: if the rippled API call fails.
"""
transaction_json = transaction.to_xrpl()
transaction_blob = encode(transaction_json)
response = client.request(SubmitOnly(tx_blob=transaction_blob))
if response.is_successful():
return response
result = cast(Dict[str, Any], response.result)
raise XRPLRequestFailureException(result)
def get_hash(self: Transaction) -> str:
"""
Hashes the Transaction object as the ledger does. Only valid for signed
Transaction objects.
Returns:
The hash of the Transaction object.
Raises:
XRPLModelException: if the Transaction is unsigned.
"""
if self.txn_signature is None:
raise XRPLModelException(
"Cannot get the hash from an unsigned Transaction.")
prefix = hex(_TRANSACTION_HASH_PREFIX)[2:].upper()
encoded_str = bytes.fromhex(prefix + encode(self.to_xrpl()))
return sha512(encoded_str).digest().hex().upper()[:64]
def safe_sign_transaction(transaction: Transaction, wallet: Wallet) -> str:
"""
Signs a transaction locally, without trusting external rippled nodes.
Args:
transaction: the transaction to be signed.
wallet: the wallet with which to sign the transaction.
Returns:
The signed transaction blob.
"""
# Increment the wallet sequence number, since we're about to use one.
wallet.next_sequence_num += 1
transaction_json = transaction_json_to_binary_codec_form(
transaction.to_dict())
transaction_json["SigningPubKey"] = wallet.pub_key
serialized_for_signing = encode_for_signing(transaction_json)
serialized_bytes = bytes.fromhex(serialized_for_signing)
signature = sign(serialized_bytes, wallet.priv_key)
transaction_json["TxnSignature"] = signature
return encode(transaction_json)
from tests.integration.reusable_values import WALLET
from xrpl.core.binarycodec import encode
from xrpl.models.amounts import IssuedCurrencyAmount
from xrpl.models.requests import SubmitOnly
from xrpl.models.transactions import OfferCreate
from xrpl.transaction import (
safe_sign_and_autofill_transaction,
transaction_json_to_binary_codec_form,
)
TX = OfferCreate(
account=WALLET.classic_address,
sequence=WALLET.sequence,
last_ledger_sequence=WALLET.sequence + 10,
taker_gets="13100000",
taker_pays=IssuedCurrencyAmount(
currency="USD",
issuer=WALLET.classic_address,
value="10",
),
)
TRANSACTION = safe_sign_and_autofill_transaction(TX, WALLET, JSON_RPC_CLIENT)
TX_JSON = transaction_json_to_binary_codec_form(TRANSACTION.to_dict())
TX_BLOB = encode(TX_JSON)
class TestSubmitOnly(TestCase):
def test_basic_functionality(self):
response = JSON_RPC_CLIENT.request(SubmitOnly(tx_blob=TX_BLOB, ))
self.assertTrue(response.is_successful())