From 7adf9857cd58ed6bd3424c9e9edf8572b89dacbf Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 12:45:42 -0400 Subject: [PATCH 01/18] fix EscrowCreate test --- .../transactions/test_escrow_create.py | 20 +++++++++---------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/tests/integration/transactions/test_escrow_create.py b/tests/integration/transactions/test_escrow_create.py index da92f5bd6..4e1df99ac 100644 --- a/tests/integration/transactions/test_escrow_create.py +++ b/tests/integration/transactions/test_escrow_create.py @@ -3,16 +3,13 @@ sign_and_reliable_submission_async, test_async_and_sync, ) -from tests.integration.reusable_values import WALLET +from tests.integration.reusable_values import DESTINATION, WALLET +from xrpl.models import EscrowCreate, Ledger from xrpl.models.response import ResponseStatus -from xrpl.models.transactions import EscrowCreate ACCOUNT = WALLET.address AMOUNT = "10000" -DESTINATION = "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW" -CANCEL_AFTER = 533257958 -FINISH_AFTER = 533171558 CONDITION = ( "A0258020E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855810100" ) @@ -23,18 +20,19 @@ class TestEscrowCreate(IntegrationTestCase): @test_async_and_sync(globals()) async def test_all_fields(self, client): + ledger = await client.request(Ledger(ledger_index="validated")) + close_time = ledger.result["ledger"]["close_time"] escrow_create = EscrowCreate( - account=ACCOUNT, + account=WALLET.classic_address, amount=AMOUNT, - destination=DESTINATION, + destination=DESTINATION.classic_address, destination_tag=DESTINATION_TAG, - cancel_after=CANCEL_AFTER, - finish_after=FINISH_AFTER, + cancel_after=close_time + 3, + finish_after=close_time + 2, source_tag=SOURCE_TAG, ) response = await sign_and_reliable_submission_async( escrow_create, WALLET, client ) - # Actual engine_result will be `tecNO_PERMISSION`... - # maybe due to CONDITION or something self.assertEqual(response.status, ResponseStatus.SUCCESS) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") From 4bb3a31012566fe9322f85dfd875c49147b4addb Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 12:55:45 -0400 Subject: [PATCH 02/18] add XChainCreateBridge integration test --- .../transactions/test_ticket_create.py | 1 + .../transactions/test_xchain_create_bridge.py | 32 +++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_create_bridge.py diff --git a/tests/integration/transactions/test_ticket_create.py b/tests/integration/transactions/test_ticket_create.py index 0cb372bc1..1311b1199 100644 --- a/tests/integration/transactions/test_ticket_create.py +++ b/tests/integration/transactions/test_ticket_create.py @@ -19,3 +19,4 @@ async def test_basic_functionality(self, client): client, ) self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") diff --git a/tests/integration/transactions/test_xchain_create_bridge.py b/tests/integration/transactions/test_xchain_create_bridge.py new file mode 100644 index 000000000..6faf2849c --- /dev/null +++ b/tests/integration/transactions/test_xchain_create_bridge.py @@ -0,0 +1,32 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import ( + MASTER_ACCOUNT, + fund_wallet_async, + submit_transaction_async, + test_async_and_sync, +) +from xrpl.models import XRP, XChainBridge, XChainCreateBridge +from xrpl.wallet import Wallet + + +class TestXChainCreateBridge(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + door_wallet = Wallet.create() + await fund_wallet_async(door_wallet) + response = await submit_transaction_async( + XChainCreateBridge( + account=door_wallet.classic_address, + xchain_bridge=XChainBridge( + locking_chain_door=door_wallet.classic_address, + locking_chain_issue=XRP(), + issuing_chain_door=MASTER_ACCOUNT, + issuing_chain_issue=XRP(), + ), + signature_reward="200", + min_account_create_amount="10000000", + ), + door_wallet, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") From b85b6145be073c886a6f6c4f0e1ffe076139c327 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:00:38 -0400 Subject: [PATCH 03/18] add reusable bridge --- tests/integration/reusable_values.py | 63 ++++++++++++++++++++-------- 1 file changed, 46 insertions(+), 17 deletions(-) diff --git a/tests/integration/reusable_values.py b/tests/integration/reusable_values.py index 5aeb75ef0..ec1613093 100644 --- a/tests/integration/reusable_values.py +++ b/tests/integration/reusable_values.py @@ -1,10 +1,18 @@ import asyncio from tests.integration.it_utils import ( + MASTER_ACCOUNT, fund_wallet_async, sign_and_reliable_submission_async, ) -from xrpl.models import IssuedCurrencyAmount, OfferCreate, PaymentChannelCreate +from xrpl.models import ( + XRP, + IssuedCurrencyAmount, + OfferCreate, + PaymentChannelCreate, + XChainBridge, + XChainCreateBridge, +) from xrpl.wallet import Wallet @@ -12,46 +20,67 @@ # TODO: set up wallet for each test instead of using one for all tests (now that it's # faster) async def _set_up_reusable_values(): - WALLET = Wallet.create() - await fund_wallet_async(WALLET) - DESTINATION = Wallet.create() - await fund_wallet_async(DESTINATION) + wallet = Wallet.create() + await fund_wallet_async(wallet) + destination = Wallet.create() + await fund_wallet_async(destination) + door_wallet = Wallet.create() + await fund_wallet_async(door_wallet) - OFFER = await sign_and_reliable_submission_async( + offer = await sign_and_reliable_submission_async( OfferCreate( - account=WALLET.address, + account=wallet.address, taker_gets="13100000", taker_pays=IssuedCurrencyAmount( currency="USD", - issuer=WALLET.address, + issuer=wallet.address, value="10", ), ), - WALLET, + wallet, ) - PAYMENT_CHANNEL = await sign_and_reliable_submission_async( + payment_channel = await sign_and_reliable_submission_async( PaymentChannelCreate( - account=WALLET.address, + account=wallet.address, amount="1", destination=DESTINATION.address, settle_delay=86400, - public_key=WALLET.public_key, + public_key=wallet.public_key, + ), + wallet, + ) + + bridge = await sign_and_reliable_submission_async( + XChainCreateBridge( + account=door_wallet.address, + xchain_bridge=XChainBridge( + locking_chain_door=door_wallet.address, + locking_chain_issue=XRP(), + issuing_chain_door=MASTER_ACCOUNT, + issuing_chain_issue=XRP(), + ), + signature_reward="200", + min_account_create_amount="10000000", ), - WALLET, + door_wallet, ) return ( - WALLET, - DESTINATION, - OFFER, - PAYMENT_CHANNEL, + wallet, + destination, + door_wallet, + offer, + payment_channel, + bridge, ) ( WALLET, DESTINATION, + DOOR_WALLET, OFFER, PAYMENT_CHANNEL, + BRIDGE, ) = asyncio.run(_set_up_reusable_values()) From 73a74c5b45876533d9ba772b152e7e647e0234d0 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:12:41 -0400 Subject: [PATCH 04/18] improve XChainCreateBridge test --- .../transactions/test_xchain_create_bridge.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/tests/integration/transactions/test_xchain_create_bridge.py b/tests/integration/transactions/test_xchain_create_bridge.py index 6faf2849c..26c3df638 100644 --- a/tests/integration/transactions/test_xchain_create_bridge.py +++ b/tests/integration/transactions/test_xchain_create_bridge.py @@ -5,7 +5,13 @@ submit_transaction_async, test_async_and_sync, ) -from xrpl.models import XRP, XChainBridge, XChainCreateBridge +from xrpl.models import ( + XRP, + AccountObjects, + AccountObjectType, + XChainBridge, + XChainCreateBridge, +) from xrpl.wallet import Wallet @@ -30,3 +36,10 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_objects_response = await client.request( + AccountObjects( + account=door_wallet.classic_address, type=AccountObjectType.BRIDGE + ) + ) + self.assertEqual(len(account_objects_response.result["account_objects"]), 1) From 65b63caca020efeabb0a5e89a9bf9cf321f3500b Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:22:10 -0400 Subject: [PATCH 05/18] add XChainCreateClaimID integration test --- tests/integration/reusable_values.py | 23 ++++++------ .../test_xchain_create_claim_id.py | 35 +++++++++++++++++++ 2 files changed, 47 insertions(+), 11 deletions(-) create mode 100644 tests/integration/transactions/test_xchain_create_claim_id.py diff --git a/tests/integration/reusable_values.py b/tests/integration/reusable_values.py index ec1613093..d8ac65cc2 100644 --- a/tests/integration/reusable_values.py +++ b/tests/integration/reusable_values.py @@ -51,18 +51,19 @@ async def _set_up_reusable_values(): wallet, ) - bridge = await sign_and_reliable_submission_async( - XChainCreateBridge( - account=door_wallet.address, - xchain_bridge=XChainBridge( - locking_chain_door=door_wallet.address, - locking_chain_issue=XRP(), - issuing_chain_door=MASTER_ACCOUNT, - issuing_chain_issue=XRP(), - ), - signature_reward="200", - min_account_create_amount="10000000", + bridge = XChainCreateBridge( + account=door_wallet.address, + xchain_bridge=XChainBridge( + locking_chain_door=door_wallet.address, + locking_chain_issue=XRP(), + issuing_chain_door=MASTER_ACCOUNT, + issuing_chain_issue=XRP(), ), + signature_reward="200", + min_account_create_amount="10000000", + ) + await sign_and_reliable_submission_async( + bridge, door_wallet, ) diff --git a/tests/integration/transactions/test_xchain_create_claim_id.py b/tests/integration/transactions/test_xchain_create_claim_id.py new file mode 100644 index 000000000..27735b2ce --- /dev/null +++ b/tests/integration/transactions/test_xchain_create_claim_id.py @@ -0,0 +1,35 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import ( + fund_wallet_async, + submit_transaction_async, + test_async_and_sync, +) +from tests.integration.reusable_values import BRIDGE +from xrpl.models import AccountObjects, AccountObjectType, XChainCreateClaimID +from xrpl.wallet import Wallet + + +class TestXChainCreateClaimID(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + account = Wallet.create() + await fund_wallet_async(account) + response = await submit_transaction_async( + XChainCreateClaimID( + account=account.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + other_chain_source=Wallet.create().classic_address, + signature_reward=BRIDGE.signature_reward, + ), + account, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_objects_response = await client.request( + AccountObjects( + account=account.classic_address, + type=AccountObjectType.XCHAIN_OWNED_CLAIM_ID, + ) + ) + self.assertEqual(len(account_objects_response.result["account_objects"]), 1) From d281fbe793e696fc80a64660cfadfeae2a19bef1 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:29:42 -0400 Subject: [PATCH 06/18] add XChainCommit integration test --- .../transactions/test_xchain_commit.py | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_commit.py diff --git a/tests/integration/transactions/test_xchain_commit.py b/tests/integration/transactions/test_xchain_commit.py new file mode 100644 index 000000000..3bc781b32 --- /dev/null +++ b/tests/integration/transactions/test_xchain_commit.py @@ -0,0 +1,29 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.reusable_values import BRIDGE, WALLET +from xrpl.models import AccountInfo, XChainCommit + + +class TestXChainCreateClaimID(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + locking_chain_door = BRIDGE.xchain_bridge.locking_chain_door + account_info1 = await client.request(AccountInfo(account=locking_chain_door)) + initial_balance = int(account_info1.result["account_data"]["Balance"]) + amount = 1000000 + + response = await submit_transaction_async( + XChainCommit( + account=WALLET.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + amount=str(amount), + xchain_claim_id=1, + ), + WALLET, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_info2 = await client.request(AccountInfo(account=locking_chain_door)) + final_balance = int(account_info2.result["account_data"]["Balance"]) + self.assertEqual(final_balance, initial_balance + amount) From 97296fdefc492b7f950abdb2029aaa25db6b6f08 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:34:02 -0400 Subject: [PATCH 07/18] add XChainAccountCreateCommit integration test --- .../test_xchain_account_create_commit.py | 33 +++++++++++++++++++ .../transactions/test_xchain_commit.py | 2 +- 2 files changed, 34 insertions(+), 1 deletion(-) create mode 100644 tests/integration/transactions/test_xchain_account_create_commit.py diff --git a/tests/integration/transactions/test_xchain_account_create_commit.py b/tests/integration/transactions/test_xchain_account_create_commit.py new file mode 100644 index 000000000..9a500b925 --- /dev/null +++ b/tests/integration/transactions/test_xchain_account_create_commit.py @@ -0,0 +1,33 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.reusable_values import BRIDGE, WALLET +from xrpl.models import AccountInfo, XChainAccountCreateCommit +from xrpl.wallet import Wallet + + +class TestXChainAccountCreateCommit(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + locking_chain_door = BRIDGE.xchain_bridge.locking_chain_door + account_info1 = await client.request(AccountInfo(account=locking_chain_door)) + initial_balance = int(account_info1.result["account_data"]["Balance"]) + amount = int(BRIDGE.min_account_create_amount) + + response = await submit_transaction_async( + XChainAccountCreateCommit( + account=WALLET.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + amount=str(amount), + signature_reward=BRIDGE.signature_reward, + destination=Wallet.create().classic_address, + ), + WALLET, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_info2 = await client.request(AccountInfo(account=locking_chain_door)) + final_balance = int(account_info2.result["account_data"]["Balance"]) + self.assertEqual( + final_balance, initial_balance + amount + int(BRIDGE.signature_reward) + ) diff --git a/tests/integration/transactions/test_xchain_commit.py b/tests/integration/transactions/test_xchain_commit.py index 3bc781b32..b845870ae 100644 --- a/tests/integration/transactions/test_xchain_commit.py +++ b/tests/integration/transactions/test_xchain_commit.py @@ -4,7 +4,7 @@ from xrpl.models import AccountInfo, XChainCommit -class TestXChainCreateClaimID(IntegrationTestCase): +class TestXChainCommit(IntegrationTestCase): @test_async_and_sync(globals()) async def test_basic_functionality(self, client): locking_chain_door = BRIDGE.xchain_bridge.locking_chain_door From 81b561c4f360cfeb3c00d5d01a4d0983421dd322 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 13:50:05 -0400 Subject: [PATCH 08/18] add XChainModifyBridge integration test --- .../transactions/test_xchain_modify_bridge.py | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_modify_bridge.py diff --git a/tests/integration/transactions/test_xchain_modify_bridge.py b/tests/integration/transactions/test_xchain_modify_bridge.py new file mode 100644 index 000000000..2b9d297d1 --- /dev/null +++ b/tests/integration/transactions/test_xchain_modify_bridge.py @@ -0,0 +1,74 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import ( + MASTER_ACCOUNT, + fund_wallet_async, + submit_transaction_async, + test_async_and_sync, +) +from xrpl.models import ( + XRP, + AccountObjects, + AccountObjectType, + XChainBridge, + XChainCreateBridge, + XChainModifyBridge, +) +from xrpl.wallet import Wallet + + +class TestXChainCreateBridge(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + door_wallet = Wallet.create() + await fund_wallet_async(door_wallet) + response = await submit_transaction_async( + XChainCreateBridge( + account=door_wallet.classic_address, + xchain_bridge=XChainBridge( + locking_chain_door=door_wallet.classic_address, + locking_chain_issue=XRP(), + issuing_chain_door=MASTER_ACCOUNT, + issuing_chain_issue=XRP(), + ), + signature_reward="200", + min_account_create_amount="10000000", + ), + door_wallet, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_objects1 = await client.request( + AccountObjects( + account=door_wallet.classic_address, type=AccountObjectType.BRIDGE + ) + ) + self.assertEqual(len(account_objects1.result["account_objects"]), 1) + bridge1 = account_objects1.result["account_objects"][0] + self.assertEqual(bridge1["SignatureReward"], "200") + + response = await submit_transaction_async( + XChainModifyBridge( + account=door_wallet.classic_address, + xchain_bridge=XChainBridge( + locking_chain_door=door_wallet.classic_address, + locking_chain_issue=XRP(), + issuing_chain_door=MASTER_ACCOUNT, + issuing_chain_issue=XRP(), + ), + signature_reward="300", + min_account_create_amount="10000000", + ), + door_wallet, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + account_objects2 = await client.request( + AccountObjects( + account=door_wallet.classic_address, type=AccountObjectType.BRIDGE + ) + ) + self.assertEqual(len(account_objects2.result["account_objects"]), 1) + bridge2 = account_objects2.result["account_objects"][0] + self.assertEqual(bridge2["SignatureReward"], "300") From 1870a6ec25fa367a7dc19997aa676b28a58694e8 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 15:03:20 -0400 Subject: [PATCH 09/18] add XChainAddAccountCreateAttestation integration test --- tests/integration/reusable_values.py | 19 ++++++ ...t_xchain_add_account_create_attestation.py | 63 +++++++++++++++++++ 2 files changed, 82 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_add_account_create_attestation.py diff --git a/tests/integration/reusable_values.py b/tests/integration/reusable_values.py index d8ac65cc2..3ba8feb11 100644 --- a/tests/integration/reusable_values.py +++ b/tests/integration/reusable_values.py @@ -10,6 +10,8 @@ IssuedCurrencyAmount, OfferCreate, PaymentChannelCreate, + SignerEntry, + SignerListSet, XChainBridge, XChainCreateBridge, ) @@ -26,6 +28,8 @@ async def _set_up_reusable_values(): await fund_wallet_async(destination) door_wallet = Wallet.create() await fund_wallet_async(door_wallet) + witness_wallet = Wallet.create() + await fund_wallet_async(witness_wallet) offer = await sign_and_reliable_submission_async( OfferCreate( @@ -66,11 +70,25 @@ async def _set_up_reusable_values(): bridge, door_wallet, ) + await sign_and_reliable_submission_async( + SignerListSet( + account=door_wallet.classic_address, + signer_entries=[ + SignerEntry( + account=witness_wallet.classic_address, + signer_weight=1, + ) + ], + signer_quorum=1, + ), + door_wallet, + ) return ( wallet, destination, door_wallet, + witness_wallet, offer, payment_channel, bridge, @@ -81,6 +99,7 @@ async def _set_up_reusable_values(): WALLET, DESTINATION, DOOR_WALLET, + WITNESS_WALLET, OFFER, PAYMENT_CHANNEL, BRIDGE, diff --git a/tests/integration/transactions/test_xchain_add_account_create_attestation.py b/tests/integration/transactions/test_xchain_add_account_create_attestation.py new file mode 100644 index 000000000..909105b06 --- /dev/null +++ b/tests/integration/transactions/test_xchain_add_account_create_attestation.py @@ -0,0 +1,63 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.reusable_values import BRIDGE, WITNESS_WALLET +from xrpl.asyncio.account import does_account_exist +from xrpl.core.binarycodec import encode +from xrpl.core.keypairs import sign +from xrpl.models import ( + AccountObjects, + AccountObjectType, + XChainAddAccountCreateAttestation, +) +from xrpl.utils import xrp_to_drops +from xrpl.wallet import Wallet + + +class TestXChainAddAccountCreateAttestation(IntegrationTestCase): + @test_async_and_sync(globals(), ["xrpl.account.does_account_exist"]) + async def test_basic_functionality(self, client): + destination = Wallet.create().classic_address + other_chain_source = Wallet.create().classic_address + self.assertFalse(await does_account_exist(destination, client)) + + account_objects = await client.request( + AccountObjects( + account=BRIDGE.xchain_bridge.locking_chain_door, + type=AccountObjectType.BRIDGE, + ) + ) + bridge_obj = account_objects.result["account_objects"][0] + + attestation_to_sign = { + "XChainBridge": BRIDGE.to_xrpl()["XChainBridge"], + "OtherChainSource": other_chain_source, + "Amount": xrp_to_drops(300), + "AttestationRewardAccount": WITNESS_WALLET.classic_address, + "WasLockingChainSend": 0, + "XChainAccountCreateCount": int(bridge_obj["XChainAccountClaimCount"]) + 1, + "Destination": destination, + "SignatureReward": BRIDGE.signature_reward, + } + encoded_attestation = encode(attestation_to_sign) + attestation_signature = sign( + encoded_attestation, + WITNESS_WALLET.private_key, + ) + + response = await submit_transaction_async( + XChainAddAccountCreateAttestation.from_xrpl( + { + "Account": WITNESS_WALLET.classic_address, + "AttestationSignerAccount": WITNESS_WALLET.classic_address, + **attestation_to_sign, + "PublicKey": WITNESS_WALLET.public_key, + "Signature": attestation_signature, + } + ), + WITNESS_WALLET, + client, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + + self.assertTrue(await does_account_exist(destination, client)) From 3fabf6b3a05862be821825d9bb2d2456e9cd51fd Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 15:44:46 -0400 Subject: [PATCH 10/18] add XChainAddClaimAttestation integration test --- .../test_xchain_add_claim_attestation.py | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_add_claim_attestation.py diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py new file mode 100644 index 000000000..a3ed827da --- /dev/null +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -0,0 +1,81 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.reusable_values import BRIDGE, DESTINATION, WITNESS_WALLET +from xrpl.core.binarycodec import encode +from xrpl.core.keypairs import sign +from xrpl.models import AccountInfo, XChainAddClaimAttestation, XChainCreateClaimID +from xrpl.utils import xrp_to_drops +from xrpl.wallet import Wallet + + +class TestXChainAddClaimAttestation(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + other_chain_source = Wallet.create().classic_address + claim_id_response = await submit_transaction_async( + XChainCreateClaimID( + account=DESTINATION.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + signature_reward=BRIDGE.signature_reward, + other_chain_source=other_chain_source, + ), + DESTINATION, + client, + ) + + nodes = claim_id_response.result["meta"]["AffectedNodes"] + created_nodes = [ + node["CreatedNode"] for node in nodes if "CreatedNode" in node.keys() + ] + claim_ids_ledger_entries = [ + node + for node in created_nodes + if node["LedgerEntryType"] == "XChainOwnedClaimID" + ] + assert len(claim_ids_ledger_entries) == 1, len(claim_ids_ledger_entries) + xchain_claim_id = claim_ids_ledger_entries[0]["NewFields"]["XChainClaimID"] + + account_info1 = await client.request( + AccountInfo(account=DESTINATION.classic_address) + ) + initial_balance = int(account_info1.result["account_data"]["Balance"]) + amount = xrp_to_drops(300) + + attestation_to_sign = { + "XChainBridge": BRIDGE.to_xrpl()["XChainBridge"], + "OtherChainSource": other_chain_source, + "Amount": amount, + "AttestationRewardAccount": WITNESS_WALLET.classic_address, + "WasLockingChainSend": 0, + "XChainClaimID": xchain_claim_id, + "Destination": DESTINATION.classic_address, + } + encoded_attestation = encode(attestation_to_sign) + attestation_signature = sign( + encoded_attestation, + WITNESS_WALLET.private_key, + ) + + response = await submit_transaction_async( + XChainAddClaimAttestation.from_xrpl( + { + "Account": WITNESS_WALLET.classic_address, + "AttestationSignerAccount": WITNESS_WALLET.classic_address, + **attestation_to_sign, + "PublicKey": WITNESS_WALLET.public_key, + "Signature": attestation_signature, + } + ), + WITNESS_WALLET, + client, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["meta"]["TransactionResult"], "tesSUCCESS") + + account_info2 = await client.request( + AccountInfo(account=DESTINATION.classic_address) + ) + final_balance = int(account_info2.result["account_data"]["Balance"]) + self.assertEqual( + final_balance, initial_balance + int(amount) - int(BRIDGE.signature_reward) + ) From 8e32f68348ed9afb372ede9c02c3f4e818728ea0 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 16:03:26 -0400 Subject: [PATCH 11/18] fix tests --- ...t_xchain_add_account_create_attestation.py | 9 +++++++-- .../test_xchain_add_claim_attestation.py | 20 ++++++++++++++----- 2 files changed, 22 insertions(+), 7 deletions(-) diff --git a/tests/integration/transactions/test_xchain_add_account_create_attestation.py b/tests/integration/transactions/test_xchain_add_account_create_attestation.py index 909105b06..1ba94c590 100644 --- a/tests/integration/transactions/test_xchain_add_account_create_attestation.py +++ b/tests/integration/transactions/test_xchain_add_account_create_attestation.py @@ -1,5 +1,9 @@ from tests.integration.integration_test_case import IntegrationTestCase -from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.it_utils import ( + LEDGER_ACCEPT_REQUEST, + submit_transaction_async, + test_async_and_sync, +) from tests.integration.reusable_values import BRIDGE, WITNESS_WALLET from xrpl.asyncio.account import does_account_exist from xrpl.core.binarycodec import encode @@ -40,7 +44,7 @@ async def test_basic_functionality(self, client): } encoded_attestation = encode(attestation_to_sign) attestation_signature = sign( - encoded_attestation, + bytes.fromhex(encoded_attestation), WITNESS_WALLET.private_key, ) @@ -59,5 +63,6 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") + await client.request(LEDGER_ACCEPT_REQUEST) self.assertTrue(await does_account_exist(destination, client)) diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py index a3ed827da..ce482d937 100644 --- a/tests/integration/transactions/test_xchain_add_claim_attestation.py +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -1,9 +1,13 @@ from tests.integration.integration_test_case import IntegrationTestCase -from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.it_utils import ( + LEDGER_ACCEPT_REQUEST, + submit_transaction_async, + test_async_and_sync, +) from tests.integration.reusable_values import BRIDGE, DESTINATION, WITNESS_WALLET from xrpl.core.binarycodec import encode from xrpl.core.keypairs import sign -from xrpl.models import AccountInfo, XChainAddClaimAttestation, XChainCreateClaimID +from xrpl.models import AccountInfo, Tx, XChainAddClaimAttestation, XChainCreateClaimID from xrpl.utils import xrp_to_drops from xrpl.wallet import Wallet @@ -22,8 +26,13 @@ async def test_basic_functionality(self, client): DESTINATION, client, ) + await client.request(LEDGER_ACCEPT_REQUEST) + claim_id_hash = ( + claim_id_response.result.get("tx_json") or claim_id_response.result + )["hash"] + claim_id_tx_response = await client.request(Tx(transaction=claim_id_hash)) - nodes = claim_id_response.result["meta"]["AffectedNodes"] + nodes = claim_id_tx_response.result["meta"]["AffectedNodes"] created_nodes = [ node["CreatedNode"] for node in nodes if "CreatedNode" in node.keys() ] @@ -52,7 +61,7 @@ async def test_basic_functionality(self, client): } encoded_attestation = encode(attestation_to_sign) attestation_signature = sign( - encoded_attestation, + bytes.fromhex(encoded_attestation), WITNESS_WALLET.private_key, ) @@ -70,7 +79,8 @@ async def test_basic_functionality(self, client): client, ) self.assertTrue(response.is_successful()) - self.assertEqual(response.result["meta"]["TransactionResult"], "tesSUCCESS") + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + await client.request(LEDGER_ACCEPT_REQUEST) account_info2 = await client.request( AccountInfo(account=DESTINATION.classic_address) From b4d599b1aedfa6ce7269cac4cdc3b2242954c891 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 16:14:44 -0400 Subject: [PATCH 12/18] add XChainClaim integration test --- .../transactions/test_xchain_claim.py | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 tests/integration/transactions/test_xchain_claim.py diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py new file mode 100644 index 000000000..1357606d4 --- /dev/null +++ b/tests/integration/transactions/test_xchain_claim.py @@ -0,0 +1,118 @@ +from tests.integration.integration_test_case import IntegrationTestCase +from tests.integration.it_utils import ( + LEDGER_ACCEPT_REQUEST, + submit_transaction_async, + test_async_and_sync, +) +from tests.integration.reusable_values import BRIDGE, DESTINATION, WITNESS_WALLET +from xrpl.core.binarycodec import encode +from xrpl.core.keypairs import sign +from xrpl.models import ( + AccountInfo, + Tx, + XChainAddClaimAttestation, + XChainClaim, + XChainCreateClaimID, +) +from xrpl.utils import xrp_to_drops +from xrpl.wallet import Wallet + + +class TestXChainAddClaimAttestation(IntegrationTestCase): + @test_async_and_sync(globals()) + async def test_basic_functionality(self, client): + other_chain_source = Wallet.create().classic_address + claim_id_response = await submit_transaction_async( + XChainCreateClaimID( + account=DESTINATION.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + signature_reward=BRIDGE.signature_reward, + other_chain_source=other_chain_source, + ), + DESTINATION, + client, + ) + await client.request(LEDGER_ACCEPT_REQUEST) + claim_id_hash = ( + claim_id_response.result.get("tx_json") or claim_id_response.result + )["hash"] + claim_id_tx_response = await client.request(Tx(transaction=claim_id_hash)) + + nodes = claim_id_tx_response.result["meta"]["AffectedNodes"] + created_nodes = [ + node["CreatedNode"] for node in nodes if "CreatedNode" in node.keys() + ] + claim_ids_ledger_entries = [ + node + for node in created_nodes + if node["LedgerEntryType"] == "XChainOwnedClaimID" + ] + assert len(claim_ids_ledger_entries) == 1, len(claim_ids_ledger_entries) + xchain_claim_id = claim_ids_ledger_entries[0]["NewFields"]["XChainClaimID"] + + account_info1 = await client.request( + AccountInfo(account=DESTINATION.classic_address) + ) + initial_balance = int(account_info1.result["account_data"]["Balance"]) + amount = xrp_to_drops(300) + + attestation_to_sign = { + "XChainBridge": BRIDGE.to_xrpl()["XChainBridge"], + "OtherChainSource": other_chain_source, + "Amount": amount, + "AttestationRewardAccount": WITNESS_WALLET.classic_address, + "WasLockingChainSend": 0, + "XChainClaimID": xchain_claim_id, + } + encoded_attestation = encode(attestation_to_sign) + attestation_signature = sign( + bytes.fromhex(encoded_attestation), + WITNESS_WALLET.private_key, + ) + + response = await submit_transaction_async( + XChainAddClaimAttestation.from_xrpl( + { + "Account": WITNESS_WALLET.classic_address, + "AttestationSignerAccount": WITNESS_WALLET.classic_address, + **attestation_to_sign, + "PublicKey": WITNESS_WALLET.public_key, + "Signature": attestation_signature, + } + ), + WITNESS_WALLET, + client, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + await client.request(LEDGER_ACCEPT_REQUEST) + + account_info2 = await client.request( + AccountInfo(account=DESTINATION.classic_address) + ) + intermediate_balance = int(account_info2.result["account_data"]["Balance"]) + self.assertEqual(intermediate_balance, initial_balance) + + response = await submit_transaction_async( + XChainClaim( + account=DESTINATION.classic_address, + xchain_bridge=BRIDGE.xchain_bridge, + xchain_claim_id=xchain_claim_id, + destination=DESTINATION.classic_address, + amount=amount, + ), + DESTINATION, + client, + ) + self.assertTrue(response.is_successful()) + self.assertEqual(response.result["engine_result"], "tesSUCCESS") + await client.request(LEDGER_ACCEPT_REQUEST) + + account_info3 = await client.request( + AccountInfo(account=DESTINATION.classic_address) + ) + final_balance = int(account_info3.result["account_data"]["Balance"]) + self.assertEqual( + final_balance, + initial_balance + int(amount) - int(BRIDGE.signature_reward) - 10, + ) From b0687df3807df9b691028087a41cd43febeabe5e Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 16:28:16 -0400 Subject: [PATCH 13/18] improve tests --- .../transactions/test_xchain_add_claim_attestation.py | 6 ++---- tests/integration/transactions/test_xchain_claim.py | 4 ++-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py index ce482d937..ffe1222cd 100644 --- a/tests/integration/transactions/test_xchain_add_claim_attestation.py +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -48,7 +48,7 @@ async def test_basic_functionality(self, client): AccountInfo(account=DESTINATION.classic_address) ) initial_balance = int(account_info1.result["account_data"]["Balance"]) - amount = xrp_to_drops(300) + amount = xrp_to_drops(3) attestation_to_sign = { "XChainBridge": BRIDGE.to_xrpl()["XChainBridge"], @@ -86,6 +86,4 @@ async def test_basic_functionality(self, client): AccountInfo(account=DESTINATION.classic_address) ) final_balance = int(account_info2.result["account_data"]["Balance"]) - self.assertEqual( - final_balance, initial_balance + int(amount) - int(BRIDGE.signature_reward) - ) + self.assertEqual(final_balance, initial_balance + int(amount)) diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py index 1357606d4..f74c4668b 100644 --- a/tests/integration/transactions/test_xchain_claim.py +++ b/tests/integration/transactions/test_xchain_claim.py @@ -54,7 +54,7 @@ async def test_basic_functionality(self, client): AccountInfo(account=DESTINATION.classic_address) ) initial_balance = int(account_info1.result["account_data"]["Balance"]) - amount = xrp_to_drops(300) + amount = xrp_to_drops(3) attestation_to_sign = { "XChainBridge": BRIDGE.to_xrpl()["XChainBridge"], @@ -114,5 +114,5 @@ async def test_basic_functionality(self, client): final_balance = int(account_info3.result["account_data"]["Balance"]) self.assertEqual( final_balance, - initial_balance + int(amount) - int(BRIDGE.signature_reward) - 10, + initial_balance + int(amount) - 10, ) From 83eb04e3bdb4efde25443eb886922c4937ebd486 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 18:37:02 -0400 Subject: [PATCH 14/18] fix test name --- tests/integration/transactions/test_xchain_claim.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py index f74c4668b..3f0ba4b5b 100644 --- a/tests/integration/transactions/test_xchain_claim.py +++ b/tests/integration/transactions/test_xchain_claim.py @@ -18,7 +18,7 @@ from xrpl.wallet import Wallet -class TestXChainAddClaimAttestation(IntegrationTestCase): +class TestXChainClaim(IntegrationTestCase): @test_async_and_sync(globals()) async def test_basic_functionality(self, client): other_chain_source = Wallet.create().classic_address From a7ab1e107fff283ec5df771cdaf48ea7273e9f85 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Wed, 3 May 2023 18:46:00 -0400 Subject: [PATCH 15/18] fix tests --- .../transactions/test_xchain_account_create_commit.py | 8 ++++++-- .../test_xchain_add_account_create_attestation.py | 4 ++-- .../transactions/test_xchain_add_claim_attestation.py | 10 ++++++---- tests/integration/transactions/test_xchain_claim.py | 10 +++++----- tests/integration/transactions/test_xchain_commit.py | 8 ++++++-- .../transactions/test_xchain_create_bridge.py | 5 +++-- .../transactions/test_xchain_create_claim_id.py | 5 +++-- .../transactions/test_xchain_modify_bridge.py | 7 ++++--- 8 files changed, 35 insertions(+), 22 deletions(-) diff --git a/tests/integration/transactions/test_xchain_account_create_commit.py b/tests/integration/transactions/test_xchain_account_create_commit.py index 9a500b925..3a5400f57 100644 --- a/tests/integration/transactions/test_xchain_account_create_commit.py +++ b/tests/integration/transactions/test_xchain_account_create_commit.py @@ -1,5 +1,8 @@ from tests.integration.integration_test_case import IntegrationTestCase -from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.it_utils import ( + sign_and_reliable_submission_async, + test_async_and_sync, +) from tests.integration.reusable_values import BRIDGE, WALLET from xrpl.models import AccountInfo, XChainAccountCreateCommit from xrpl.wallet import Wallet @@ -13,7 +16,7 @@ async def test_basic_functionality(self, client): initial_balance = int(account_info1.result["account_data"]["Balance"]) amount = int(BRIDGE.min_account_create_amount) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainAccountCreateCommit( account=WALLET.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -22,6 +25,7 @@ async def test_basic_functionality(self, client): destination=Wallet.create().classic_address, ), WALLET, + client, ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") diff --git a/tests/integration/transactions/test_xchain_add_account_create_attestation.py b/tests/integration/transactions/test_xchain_add_account_create_attestation.py index 1ba94c590..6dd9b41a2 100644 --- a/tests/integration/transactions/test_xchain_add_account_create_attestation.py +++ b/tests/integration/transactions/test_xchain_add_account_create_attestation.py @@ -1,7 +1,7 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( LEDGER_ACCEPT_REQUEST, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from tests.integration.reusable_values import BRIDGE, WITNESS_WALLET @@ -48,7 +48,7 @@ async def test_basic_functionality(self, client): WITNESS_WALLET.private_key, ) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainAddAccountCreateAttestation.from_xrpl( { "Account": WITNESS_WALLET.classic_address, diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py index ffe1222cd..2680fdd95 100644 --- a/tests/integration/transactions/test_xchain_add_claim_attestation.py +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -1,7 +1,7 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( LEDGER_ACCEPT_REQUEST, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from tests.integration.reusable_values import BRIDGE, DESTINATION, WITNESS_WALLET @@ -16,7 +16,7 @@ class TestXChainAddClaimAttestation(IntegrationTestCase): @test_async_and_sync(globals()) async def test_basic_functionality(self, client): other_chain_source = Wallet.create().classic_address - claim_id_response = await submit_transaction_async( + claim_id_response = await sign_and_reliable_submission_async( XChainCreateClaimID( account=DESTINATION.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -65,7 +65,7 @@ async def test_basic_functionality(self, client): WITNESS_WALLET.private_key, ) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainAddClaimAttestation.from_xrpl( { "Account": WITNESS_WALLET.classic_address, @@ -86,4 +86,6 @@ async def test_basic_functionality(self, client): AccountInfo(account=DESTINATION.classic_address) ) final_balance = int(account_info2.result["account_data"]["Balance"]) - self.assertEqual(final_balance, initial_balance + int(amount)) + self.assertEqual( + final_balance, initial_balance + int(amount) - int(BRIDGE.signature_reward) + ) diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py index 3f0ba4b5b..f5ea68c2c 100644 --- a/tests/integration/transactions/test_xchain_claim.py +++ b/tests/integration/transactions/test_xchain_claim.py @@ -1,7 +1,7 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( LEDGER_ACCEPT_REQUEST, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from tests.integration.reusable_values import BRIDGE, DESTINATION, WITNESS_WALLET @@ -22,7 +22,7 @@ class TestXChainClaim(IntegrationTestCase): @test_async_and_sync(globals()) async def test_basic_functionality(self, client): other_chain_source = Wallet.create().classic_address - claim_id_response = await submit_transaction_async( + claim_id_response = await sign_and_reliable_submission_async( XChainCreateClaimID( account=DESTINATION.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -70,7 +70,7 @@ async def test_basic_functionality(self, client): WITNESS_WALLET.private_key, ) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainAddClaimAttestation.from_xrpl( { "Account": WITNESS_WALLET.classic_address, @@ -93,7 +93,7 @@ async def test_basic_functionality(self, client): intermediate_balance = int(account_info2.result["account_data"]["Balance"]) self.assertEqual(intermediate_balance, initial_balance) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainClaim( account=DESTINATION.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -114,5 +114,5 @@ async def test_basic_functionality(self, client): final_balance = int(account_info3.result["account_data"]["Balance"]) self.assertEqual( final_balance, - initial_balance + int(amount) - 10, + initial_balance + int(amount) - int(BRIDGE.signature_reward) - 10, ) diff --git a/tests/integration/transactions/test_xchain_commit.py b/tests/integration/transactions/test_xchain_commit.py index b845870ae..a76552942 100644 --- a/tests/integration/transactions/test_xchain_commit.py +++ b/tests/integration/transactions/test_xchain_commit.py @@ -1,5 +1,8 @@ from tests.integration.integration_test_case import IntegrationTestCase -from tests.integration.it_utils import submit_transaction_async, test_async_and_sync +from tests.integration.it_utils import ( + sign_and_reliable_submission_async, + test_async_and_sync, +) from tests.integration.reusable_values import BRIDGE, WALLET from xrpl.models import AccountInfo, XChainCommit @@ -12,7 +15,7 @@ async def test_basic_functionality(self, client): initial_balance = int(account_info1.result["account_data"]["Balance"]) amount = 1000000 - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainCommit( account=WALLET.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -20,6 +23,7 @@ async def test_basic_functionality(self, client): xchain_claim_id=1, ), WALLET, + client, ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") diff --git a/tests/integration/transactions/test_xchain_create_bridge.py b/tests/integration/transactions/test_xchain_create_bridge.py index 26c3df638..94fbe2598 100644 --- a/tests/integration/transactions/test_xchain_create_bridge.py +++ b/tests/integration/transactions/test_xchain_create_bridge.py @@ -2,7 +2,7 @@ from tests.integration.it_utils import ( MASTER_ACCOUNT, fund_wallet_async, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from xrpl.models import ( @@ -20,7 +20,7 @@ class TestXChainCreateBridge(IntegrationTestCase): async def test_basic_functionality(self, client): door_wallet = Wallet.create() await fund_wallet_async(door_wallet) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainCreateBridge( account=door_wallet.classic_address, xchain_bridge=XChainBridge( @@ -33,6 +33,7 @@ async def test_basic_functionality(self, client): min_account_create_amount="10000000", ), door_wallet, + client, ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") diff --git a/tests/integration/transactions/test_xchain_create_claim_id.py b/tests/integration/transactions/test_xchain_create_claim_id.py index 27735b2ce..00ba2fc91 100644 --- a/tests/integration/transactions/test_xchain_create_claim_id.py +++ b/tests/integration/transactions/test_xchain_create_claim_id.py @@ -1,7 +1,7 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( fund_wallet_async, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from tests.integration.reusable_values import BRIDGE @@ -14,7 +14,7 @@ class TestXChainCreateClaimID(IntegrationTestCase): async def test_basic_functionality(self, client): account = Wallet.create() await fund_wallet_async(account) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainCreateClaimID( account=account.classic_address, xchain_bridge=BRIDGE.xchain_bridge, @@ -22,6 +22,7 @@ async def test_basic_functionality(self, client): signature_reward=BRIDGE.signature_reward, ), account, + client, ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") diff --git a/tests/integration/transactions/test_xchain_modify_bridge.py b/tests/integration/transactions/test_xchain_modify_bridge.py index 2b9d297d1..80ec7fc24 100644 --- a/tests/integration/transactions/test_xchain_modify_bridge.py +++ b/tests/integration/transactions/test_xchain_modify_bridge.py @@ -2,7 +2,7 @@ from tests.integration.it_utils import ( MASTER_ACCOUNT, fund_wallet_async, - submit_transaction_async, + sign_and_reliable_submission_async, test_async_and_sync, ) from xrpl.models import ( @@ -21,7 +21,7 @@ class TestXChainCreateBridge(IntegrationTestCase): async def test_basic_functionality(self, client): door_wallet = Wallet.create() await fund_wallet_async(door_wallet) - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainCreateBridge( account=door_wallet.classic_address, xchain_bridge=XChainBridge( @@ -34,6 +34,7 @@ async def test_basic_functionality(self, client): min_account_create_amount="10000000", ), door_wallet, + client, ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") @@ -47,7 +48,7 @@ async def test_basic_functionality(self, client): bridge1 = account_objects1.result["account_objects"][0] self.assertEqual(bridge1["SignatureReward"], "200") - response = await submit_transaction_async( + response = await sign_and_reliable_submission_async( XChainModifyBridge( account=door_wallet.classic_address, xchain_bridge=XChainBridge( From a67f057dca45fd0086158c75fccde8a575d08fe0 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Fri, 5 May 2023 17:24:47 -0400 Subject: [PATCH 16/18] clean up --- .../test_xchain_add_account_create_attestation.py | 2 -- .../transactions/test_xchain_add_claim_attestation.py | 4 +--- tests/integration/transactions/test_xchain_claim.py | 4 ---- 3 files changed, 1 insertion(+), 9 deletions(-) diff --git a/tests/integration/transactions/test_xchain_add_account_create_attestation.py b/tests/integration/transactions/test_xchain_add_account_create_attestation.py index 6dd9b41a2..3c66ba3b8 100644 --- a/tests/integration/transactions/test_xchain_add_account_create_attestation.py +++ b/tests/integration/transactions/test_xchain_add_account_create_attestation.py @@ -1,6 +1,5 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( - LEDGER_ACCEPT_REQUEST, sign_and_reliable_submission_async, test_async_and_sync, ) @@ -63,6 +62,5 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") - await client.request(LEDGER_ACCEPT_REQUEST) self.assertTrue(await does_account_exist(destination, client)) diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py index 2680fdd95..b2d8384e3 100644 --- a/tests/integration/transactions/test_xchain_add_claim_attestation.py +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -1,6 +1,5 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( - LEDGER_ACCEPT_REQUEST, sign_and_reliable_submission_async, test_async_and_sync, ) @@ -16,6 +15,7 @@ class TestXChainAddClaimAttestation(IntegrationTestCase): @test_async_and_sync(globals()) async def test_basic_functionality(self, client): other_chain_source = Wallet.create().classic_address + claim_id_response = await sign_and_reliable_submission_async( XChainCreateClaimID( account=DESTINATION.classic_address, @@ -26,7 +26,6 @@ async def test_basic_functionality(self, client): DESTINATION, client, ) - await client.request(LEDGER_ACCEPT_REQUEST) claim_id_hash = ( claim_id_response.result.get("tx_json") or claim_id_response.result )["hash"] @@ -80,7 +79,6 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") - await client.request(LEDGER_ACCEPT_REQUEST) account_info2 = await client.request( AccountInfo(account=DESTINATION.classic_address) diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py index f5ea68c2c..cc7400785 100644 --- a/tests/integration/transactions/test_xchain_claim.py +++ b/tests/integration/transactions/test_xchain_claim.py @@ -1,6 +1,5 @@ from tests.integration.integration_test_case import IntegrationTestCase from tests.integration.it_utils import ( - LEDGER_ACCEPT_REQUEST, sign_and_reliable_submission_async, test_async_and_sync, ) @@ -32,7 +31,6 @@ async def test_basic_functionality(self, client): DESTINATION, client, ) - await client.request(LEDGER_ACCEPT_REQUEST) claim_id_hash = ( claim_id_response.result.get("tx_json") or claim_id_response.result )["hash"] @@ -85,7 +83,6 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") - await client.request(LEDGER_ACCEPT_REQUEST) account_info2 = await client.request( AccountInfo(account=DESTINATION.classic_address) @@ -106,7 +103,6 @@ async def test_basic_functionality(self, client): ) self.assertTrue(response.is_successful()) self.assertEqual(response.result["engine_result"], "tesSUCCESS") - await client.request(LEDGER_ACCEPT_REQUEST) account_info3 = await client.request( AccountInfo(account=DESTINATION.classic_address) From c03924053fa97814aa73f83bfea9520c1a9805d0 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Sat, 26 Aug 2023 11:00:54 +0100 Subject: [PATCH 17/18] fix rebase issues --- tests/integration/reusable_values.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/reusable_values.py b/tests/integration/reusable_values.py index 3ba8feb11..dc295f3da 100644 --- a/tests/integration/reusable_values.py +++ b/tests/integration/reusable_values.py @@ -48,7 +48,7 @@ async def _set_up_reusable_values(): PaymentChannelCreate( account=wallet.address, amount="1", - destination=DESTINATION.address, + destination=destination.address, settle_delay=86400, public_key=wallet.public_key, ), From 8fa5ac0570ead47e8206f4b34273e0e1428468e1 Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Tue, 28 Nov 2023 11:47:44 -0800 Subject: [PATCH 18/18] simplify --- .../test_xchain_add_claim_attestation.py | 15 ++------------- .../integration/transactions/test_xchain_claim.py | 15 ++------------- 2 files changed, 4 insertions(+), 26 deletions(-) diff --git a/tests/integration/transactions/test_xchain_add_claim_attestation.py b/tests/integration/transactions/test_xchain_add_claim_attestation.py index b2d8384e3..c94b6be13 100644 --- a/tests/integration/transactions/test_xchain_add_claim_attestation.py +++ b/tests/integration/transactions/test_xchain_add_claim_attestation.py @@ -7,7 +7,7 @@ from xrpl.core.binarycodec import encode from xrpl.core.keypairs import sign from xrpl.models import AccountInfo, Tx, XChainAddClaimAttestation, XChainCreateClaimID -from xrpl.utils import xrp_to_drops +from xrpl.utils import get_xchain_claim_id, xrp_to_drops from xrpl.wallet import Wallet @@ -30,18 +30,7 @@ async def test_basic_functionality(self, client): claim_id_response.result.get("tx_json") or claim_id_response.result )["hash"] claim_id_tx_response = await client.request(Tx(transaction=claim_id_hash)) - - nodes = claim_id_tx_response.result["meta"]["AffectedNodes"] - created_nodes = [ - node["CreatedNode"] for node in nodes if "CreatedNode" in node.keys() - ] - claim_ids_ledger_entries = [ - node - for node in created_nodes - if node["LedgerEntryType"] == "XChainOwnedClaimID" - ] - assert len(claim_ids_ledger_entries) == 1, len(claim_ids_ledger_entries) - xchain_claim_id = claim_ids_ledger_entries[0]["NewFields"]["XChainClaimID"] + xchain_claim_id = get_xchain_claim_id(claim_id_tx_response.result["meta"]) account_info1 = await client.request( AccountInfo(account=DESTINATION.classic_address) diff --git a/tests/integration/transactions/test_xchain_claim.py b/tests/integration/transactions/test_xchain_claim.py index cc7400785..ebfd3eb1f 100644 --- a/tests/integration/transactions/test_xchain_claim.py +++ b/tests/integration/transactions/test_xchain_claim.py @@ -13,7 +13,7 @@ XChainClaim, XChainCreateClaimID, ) -from xrpl.utils import xrp_to_drops +from xrpl.utils import get_xchain_claim_id, xrp_to_drops from xrpl.wallet import Wallet @@ -35,18 +35,7 @@ async def test_basic_functionality(self, client): claim_id_response.result.get("tx_json") or claim_id_response.result )["hash"] claim_id_tx_response = await client.request(Tx(transaction=claim_id_hash)) - - nodes = claim_id_tx_response.result["meta"]["AffectedNodes"] - created_nodes = [ - node["CreatedNode"] for node in nodes if "CreatedNode" in node.keys() - ] - claim_ids_ledger_entries = [ - node - for node in created_nodes - if node["LedgerEntryType"] == "XChainOwnedClaimID" - ] - assert len(claim_ids_ledger_entries) == 1, len(claim_ids_ledger_entries) - xchain_claim_id = claim_ids_ledger_entries[0]["NewFields"]["XChainClaimID"] + xchain_claim_id = get_xchain_claim_id(claim_id_tx_response.result["meta"]) account_info1 = await client.request( AccountInfo(account=DESTINATION.classic_address)