test: add integration tests for sidechain transactions

tests/integration/reusable_values.py

@@ -3,62 +3,109 @@
 
 from tests.integration.it_utils import (
     ASYNC_JSON_RPC_CLIENT,
+    MASTER_ACCOUNT,
     create_amm_pool_async,
     fund_wallet_async,
     sign_and_reliable_submission_async,
 )
 from xrpl.asyncio.clients.async_client import AsyncClient
-from xrpl.models import IssuedCurrencyAmount, OfferCreate, PaymentChannelCreate
-from xrpl.models.transactions.amm_deposit import AMMDeposit, AMMDepositFlag
+from xrpl.models import (
+    XRP,
+    AMMDeposit,
+    AMMDepositFlag,
+    IssuedCurrencyAmount,
+    OfferCreate,
+    PaymentChannelCreate,
+    SignerEntry,
+    SignerListSet,
+    XChainBridge,
+    XChainCreateBridge,
+)
 from xrpl.wallet import Wallet
 
 
 # TODO: use `asyncio.gather` for these, to parallelize
 # 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)
+    witness_wallet = Wallet.create()
+    await fund_wallet_async(witness_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,
+            destination=destination.address,
             settle_delay=86400,
-            public_key=WALLET.public_key,
+            public_key=wallet.public_key,
+        ),
+        wallet,
+    )
+
+    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(),
         ),
-        WALLET,
+        signature_reward="200",
+        min_account_create_amount="10000000",
+    )
+    await sign_and_reliable_submission_async(
+        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,
     )
 
-    setup_amm_pool_res = await setup_amm_pool(wallet=WALLET)
-    AMM_ASSET = setup_amm_pool_res["asset"]
-    AMM_ASSET2 = setup_amm_pool_res["asset2"]
-    AMM_ISSUER_WALLET = setup_amm_pool_res["issuer_wallet"]
+    setup_amm_pool_res = await setup_amm_pool(wallet=wallet)
+    amm_asset = setup_amm_pool_res["asset"]
+    amm_asset2 = setup_amm_pool_res["asset2"]
+    amm_issuer_wallet = setup_amm_pool_res["issuer_wallet"]
 
     return (
-        WALLET,
-        DESTINATION,
-        OFFER,
-        PAYMENT_CHANNEL,
-        AMM_ASSET,
-        AMM_ASSET2,
-        AMM_ISSUER_WALLET,
+        wallet,
+        destination,
+        door_wallet,
+        witness_wallet,
+        offer,
+        payment_channel,
+        amm_asset,
+        amm_asset2,
+        amm_issuer_wallet,
+        bridge,
     )
 
 
@@ -94,9 +141,12 @@ async def setup_amm_pool(
 (
     WALLET,
     DESTINATION,
+    DOOR_WALLET,
+    WITNESS_WALLET,
     OFFER,
     PAYMENT_CHANNEL,
     AMM_ASSET,
     AMM_ASSET2,
     AMM_ISSUER_WALLET,
+    BRIDGE,
 ) = asyncio.run(_set_up_reusable_values())

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")

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")

tests/integration/transactions/test_xchain_account_create_commit.py

@@ -0,0 +1,37 @@
+from tests.integration.integration_test_case import IntegrationTestCase
+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
+
+
+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 sign_and_reliable_submission_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,
+            client,
+        )
+        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)
+        )

tests/integration/transactions/test_xchain_add_account_create_attestation.py

@@ -0,0 +1,66 @@
+from tests.integration.integration_test_case import IntegrationTestCase
+from tests.integration.it_utils import (
+    sign_and_reliable_submission_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(
+            bytes.fromhex(encoded_attestation),
+            WITNESS_WALLET.private_key,
+        )
+
+        response = await sign_and_reliable_submission_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))

tests/integration/transactions/test_xchain_add_claim_attestation.py

@@ -0,0 +1,89 @@
+from tests.integration.integration_test_case import IntegrationTestCase
+from tests.integration.it_utils import (
+    sign_and_reliable_submission_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, 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 sign_and_reliable_submission_async(
+            XChainCreateClaimID(
+                account=DESTINATION.classic_address,
+                xchain_bridge=BRIDGE.xchain_bridge,
+                signature_reward=BRIDGE.signature_reward,
+                other_chain_source=other_chain_source,
+            ),
+            DESTINATION,
+            client,
+        )
+        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(3)
+
+        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(
+            bytes.fromhex(encoded_attestation),
+            WITNESS_WALLET.private_key,
+        )
+
+        response = await sign_and_reliable_submission_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")
+
+        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)
+        )