def test_get_transaction_from_hash_with_binary(self):
# GIVEN a new transaction (payment)
payment_transaction = Payment(account=WALLET.classic_address,
amount="100",
destination=DESTINATION)
# WHEN we sign locally and autofill the transaction
signed_payment_transaction = safe_sign_and_autofill_transaction(
payment_transaction, WALLET, JSON_RPC_CLIENT)
# AND submit the transaction
response = send_reliable_submission(signed_payment_transaction,
JSON_RPC_CLIENT)
payment_hash = response.result["hash"]
# THEN we expect to retrieve this transaction from its hash with the
# binary parameter set to true
payment = get_transaction_from_hash(payment_hash, JSON_RPC_CLIENT,
True)
# AND we expect the result hash to be the same as the original payment hash
self.assertEqual(payment.result["hash"], payment_hash)
# AND we expect the response to be successful (200)
self.assertTrue(payment.is_successful())
WALLET.sequence += 1
def test_get_transaction_from_hash_with_min_max_ledgers(self):
# GIVEN a new transaction (payment)
payment_transaction = Payment(account=WALLET.classic_address,
amount="100",
destination=DESTINATION)
# WHEN we sign locally and autofill the transaction
signed_payment_transaction = safe_sign_and_autofill_transaction(
payment_transaction, WALLET, JSON_RPC_CLIENT)
# AND submit the transaction
response = send_reliable_submission(signed_payment_transaction,
JSON_RPC_CLIENT)
payment_hash = response.result["hash"]
payment_ledger_index = response.result["ledger_index"]
# THEN we expect to retrieve this transaction from its hash with
# min_ledger and max_ledger parameters
payment = get_transaction_from_hash(
payment_hash,
JSON_RPC_CLIENT,
False,
payment_ledger_index - 500,
payment_ledger_index + 500,
)
# AND we expect the result Account to be the same as the original payment Acct
self.assertEqual(payment.result["Account"], ACCOUNT)
# AND we expect the response to be successful (200)
self.assertTrue(payment.is_successful())
WALLET.sequence += 1
async def test_get_transaction_from_hash(self, client):
# GIVEN a new transaction (payment)
payment_transaction = Payment(
account=WALLET.classic_address,
amount="100",
destination=DESTINATION,
sequence=WALLET.sequence,
)
# WHEN we sign locally and autofill the transaction
signed_payment_transaction = await safe_sign_and_autofill_transaction(
payment_transaction, WALLET, client)
# AND submit the transaction
response = await send_reliable_submission(signed_payment_transaction,
client)
# THEN we expect to retrieve this transaction from its hash
payment = await get_transaction_from_hash(response.result["hash"],
client)
# AND we expect the result Account to be the same as the original payment Acct
self.assertEqual(payment.result["Account"], ACCOUNT)
# AND we expect the response to be successful (200)
self.assertTrue(payment.is_successful())
WALLET.sequence += 1
async def test_basic_functionality(self, client):
response = await submit_transaction_async(
Payment(
account=WALLET.classic_address,
sequence=WALLET.sequence,
amount="1",
destination=DESTINATION.classic_address,
),
WALLET,
)
self.assertTrue(response.is_successful())
WALLET.sequence += 1
def test_basic_functionality(self):
response = submit_transaction(
Payment(
account=WALLET.classic_address,
sequence=WALLET.next_sequence_num,
amount="1",
destination=DESTINATION.classic_address,
),
WALLET,
)
self.assertTrue(response.is_successful())
WALLET.next_sequence_num += 1
def payment(self, destination, sender, amount, sequence, seed) -> bool:
my_tx_payment = Payment(
account=sender,
amount=xrp_to_drops(amount),
destination=destination,
sequence=sequence,
)
sign_wallet = Wallet(seed, sequence)
my_tx_payment_signed = safe_sign_and_autofill_transaction(
my_tx_payment, sign_wallet, self.client)
tx_response = send_reliable_submission(my_tx_payment_signed,
self.client)
return True
def test_last_ledger_expiration(self):
WALLET.next_sequence_num = get_next_valid_seq_number(ACCOUNT, JSON_RPC_CLIENT)
payment_dict = {
"account": ACCOUNT,
"sequence": WALLET.next_sequence_num,
"last_ledger_sequence": WALLET.next_sequence_num + 1,
"fee": "10000",
"amount": "100",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
with self.assertRaises(LastLedgerSequenceExpiredException):
send_reliable_submission(payment_transaction, WALLET, JSON_RPC_CLIENT)
def test_calculate_payment_fee(self):
# GIVEN a new Payment transaction
payment = Payment(account=WALLET.classic_address,
amount="100",
destination=DESTINATION)
# AFTER autofilling the transaction fee
payment_signed = safe_sign_and_autofill_transaction(
payment, WALLET, JSON_RPC_CLIENT)
# THEN We expect the fee to be the default network fee (usually 10 drops)
expected_fee = get_fee(JSON_RPC_CLIENT)
self.assertEqual(payment_signed.fee, expected_fee)
async def test_reliable_submission_bad_transaction(self, client):
WALLET.sequence = await get_next_valid_seq_number(ACCOUNT, client)
payment_dict = {
"account": ACCOUNT,
"last_ledger_sequence": WALLET.sequence + 20,
"fee": "10",
"amount": "100",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
signed_payment_transaction = await safe_sign_transaction(
payment_transaction, WALLET)
with self.assertRaises(XRPLRequestFailureException):
await send_reliable_submission(signed_payment_transaction, client)
def test_reliable_submission_bad_transaction(self):
WALLET.next_sequence_num = get_next_valid_seq_number(ACCOUNT, JSON_RPC_CLIENT)
payment_dict = {
"account": ACCOUNT,
"last_ledger_sequence": WALLET.next_sequence_num + 20,
"fee": "10",
"amount": "100",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
signed_payment_transaction = safe_sign_transaction(payment_transaction, WALLET)
with self.assertRaises(XRPLRequestFailureException):
send_reliable_submission(signed_payment_transaction, JSON_RPC_CLIENT)
WALLET.next_sequence_num -= 1
def test_generate_faucet_wallet_rel_sub(self):
destination = generate_faucet_wallet(DEV_JSON_RPC_CLIENT)
wallet = generate_faucet_wallet(DEV_JSON_RPC_CLIENT)
response = submit_transaction(
Payment(
account=wallet.classic_address,
sequence=wallet.next_sequence_num,
fee="10",
amount="1",
destination=destination.classic_address,
),
wallet,
client=DEV_JSON_RPC_CLIENT,
)
self.assertTrue(response.is_successful())
async def test_generate_faucet_wallet_rel_sub(self, client):
destination = await generate_faucet_wallet(client)
wallet = await generate_faucet_wallet(client)
response = await submit_transaction_async(
Payment(
account=wallet.classic_address,
sequence=wallet.sequence,
fee="10",
amount="1",
destination=destination.classic_address,
),
wallet,
client=client,
)
self.assertTrue(response.is_successful())
async def test_calculate_payment_fee(self, client):
# GIVEN a new Payment transaction
payment = Payment(
account=WALLET.classic_address,
amount="100",
destination=DESTINATION,
sequence=WALLET.sequence,
)
# AFTER autofilling the transaction fee
payment_signed = await safe_sign_and_autofill_transaction(
payment, WALLET, client)
# THEN We expect the fee to be the default network fee (usually 10 drops)
expected_fee = await get_fee(client)
self.assertEqual(payment_signed.fee, expected_fee)
def test_reliable_submission_last_ledger_expiration(self):
WALLET.sequence = get_next_valid_seq_number(ACCOUNT, JSON_RPC_CLIENT)
payment_dict = {
"account": ACCOUNT,
"sequence": WALLET.sequence,
"last_ledger_sequence": WALLET.sequence + 1,
"fee": "10000",
"amount": "100",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
signed_payment_transaction = safe_sign_and_autofill_transaction(
payment_transaction, WALLET, JSON_RPC_CLIENT)
with self.assertRaises(XRPLReliableSubmissionException):
send_reliable_submission(signed_payment_transaction,
JSON_RPC_CLIENT)
WALLET.sequence -= 1
async def test_get_latest_transaction(self, client):
# NOTE: this test may take a long time to run
amount = "21000000"
payment = Payment(
account=WALLET.classic_address,
destination=DESTINATION.classic_address,
amount=amount,
)
await sign_and_reliable_submission_async(payment, WALLET)
WALLET.sequence += 1
response = await get_latest_transaction(WALLET.classic_address, client)
self.assertEqual(len(response.result["transactions"]), 1)
transaction = response.result["transactions"][0]["tx"]
self.assertEqual(transaction["TransactionType"], "Payment")
self.assertEqual(transaction["Amount"], amount)
self.assertEqual(transaction["Account"], WALLET.classic_address)
def test_payment(self):
WALLET.next_sequence_num = get_next_valid_seq_number(ACCOUNT, JSON_RPC_CLIENT)
payment_dict = {
"account": ACCOUNT,
"sequence": WALLET.next_sequence_num,
"last_ledger_sequence": WALLET.next_sequence_num + 10,
"fee": "10000",
"amount": "10",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
response = send_reliable_submission(
payment_transaction, WALLET, JSON_RPC_CLIENT
)
self.assertTrue(response.result["validated"])
self.assertEqual(response.result["meta"]["TransactionResult"], "tesSUCCESS")
self.assertTrue(response.is_successful())
def test_payment_high_fee_authorized(self):
# GIVEN a new Payment transaction
response = submit_transaction(
Payment(
account=WALLET.classic_address,
sequence=WALLET.sequence,
amount="1",
# WITH the fee higher than 2 XRP
fee=FEE,
destination=DESTINATION,
),
WALLET,
# WITHOUT checking the fee value
check_fee=False,
)
# THEN we expect the transaction to be successful
self.assertTrue(response.is_successful())
WALLET.sequence += 1
def test_get_latest_transaction(self):
# NOTE: this test may take a long time to run
amount = "21000000"
payment = Payment(
account=WALLET.classic_address,
destination=DESTINATION.classic_address,
amount=amount,
last_ledger_sequence=WALLET.sequence + 20,
)
sign_and_reliable_submission(payment, WALLET)
WALLET.sequence += 1
response = get_latest_transaction(WALLET.classic_address,
JSON_RPC_CLIENT)
self.assertEqual(len(response.result["transactions"]), 1)
transaction = response.result["transactions"][0]["tx"]
self.assertEqual(transaction["TransactionType"], "Payment")
self.assertEqual(transaction["Amount"], amount)
self.assertEqual(transaction["Account"], WALLET.classic_address)
def test_reliable_submission_payment(self):
WALLET.sequence = get_next_valid_seq_number(ACCOUNT, JSON_RPC_CLIENT)
payment_dict = {
"account": ACCOUNT,
"sequence": WALLET.sequence,
"amount": "10",
"destination": DESTINATION,
}
payment_transaction = Payment.from_dict(payment_dict)
signed_payment_transaction = safe_sign_and_autofill_transaction(
payment_transaction, WALLET, JSON_RPC_CLIENT)
response = send_reliable_submission(signed_payment_transaction,
JSON_RPC_CLIENT)
self.assertTrue(response.result["validated"])
self.assertEqual(response.result["meta"]["TransactionResult"],
"tesSUCCESS")
self.assertTrue(response.is_successful())
self.assertEqual(response.result["Fee"], get_fee(JSON_RPC_CLIENT))
WALLET.sequence += 1
# Derive an x-address from the classic address:
# https://xrpaddress.info/
from xrpl.core import addresscodec
test_xaddress = addresscodec.classic_address_to_xaddress(test_account,
tag=12345,
is_test_network=True)
print("\nClassic address:\n\n", test_account)
print("X-address:\n\n", test_xaddress)
# Prepare payment
from xrpl.models.transactions import Payment
from xrpl.utils import xrp_to_drops
my_tx_payment = Payment(
account=test_account,
amount=xrp_to_drops(22),
destination="rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
)
# print prepared payment
print(my_tx_payment)
# Sign the transaction
from xrpl.transaction import safe_sign_and_autofill_transaction
my_tx_payment_signed = safe_sign_and_autofill_transaction(
my_tx_payment, test_wallet, client)
# Print signed tx
print("Signed tx:", my_tx_payment_signed)
def test_to_xrpl_paths(self):
paths_json = [
[
{
"account": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
"type": 1
},
{
"currency": "USD",
"issuer": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
"type": 48,
},
{
"account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
"type": 1
},
{
"account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"type": 1
},
],
]
p = Payment(
account="rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
amount=IssuedCurrencyAmount(
currency="USD",
issuer="rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
value="0.0001",
),
destination="rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
send_max=IssuedCurrencyAmount(
currency="BTC",
issuer="rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
value="0.0000002831214446",
),
paths=paths_json,
sequence=290,
)
tx_json = p.to_xrpl()
expected = {
"Account":
"rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
"TransactionType":
"Payment",
"Sequence":
290,
"Flags":
0,
"SigningPubKey":
"",
"Amount": {
"currency": "USD",
"issuer": "rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
"value": "0.0001",
},
"Destination":
"rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
"Paths": [[
{
"account": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
"type": 1
},
{
"currency": "USD",
"issuer": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
"type": 48,
},
{
"account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
"type": 1
},
{
"account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"type": 1
},
]],
"SendMax": {
"currency": "BTC",
"issuer": "rweYz56rfmQ98cAdRaeTxQS9wVMGnrdsFp",
"value": "0.0000002831214446",
},
}
self.assertEqual(tx_json, expected)
# Define signer address
import os
my_secret = os.getenv("MYSECRET")
from xrpl.wallet import Wallet
wallet = Wallet(seed="MYSECRET", sequence=16237283)
print(wallet.classic_address) # "raaFKKmgf6CRZttTVABeTcsqzRQ51bNR6Q"
from xrpl.models.transactions import Payment
from xrpl.utils import xrp_to_drops
my_payment = Payment(
account=wallet.classic_address,
amount=xrp_to_drops(22),
fee="10",
destination="rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
sequence=16126889,
)
print("Payment object:", my_payment)
# Sign transaction -------------------------------------------------------------
import xrpl.transaction
signed = xrpl.transaction.safe_sign_transaction(my_payment, wallet)
print("Signed transaction blob:", signed)
# Define signer address
import os
my_secret = os.getenv("MYSECRET")
from xrpl.wallet import Wallet
wallet = Wallet(seed=my_secret, sequence=16237283)
print(wallet.classic_address) # "raaFKKmgf6CRZttTVABeTcsqzRQ51bNR6Q"
from xrpl.models.transactions import Payment
from xrpl.utils import xrp_to_drops
my_payment = Payment(
account=wallet.classic_address,
amount=xrp_to_drops(22),
fee="10",
destination="rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
sequence=wallet.
sequence, # this needs to be incremented upon every successful transaction
)
print("Payment object:", my_payment)
# Sign transaction -------------------------------------------------------------
import xrpl.transaction
signed = xrpl.transaction.safe_sign_transaction(my_payment, wallet)
print("Signed transaction blob:", signed)
