Single Asset Vault XLS-65d

.ci-config/rippled.cfg

@@ -196,6 +196,7 @@ fixEnforceNFTokenTrustline
 fixReducedOffersV2
 DeepFreeze
 PermissionedDomains
+SingleAssetVault
 
 # This section can be used to simulate various FeeSettings scenarios for rippled node in standalone mode
 [voting]

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Improved validation for models to also check param types
+- Support for Single Asset Vault (XLS-65d)
 
 ## [4.1.0] - 2025-2-13
 

tests/integration/transactions/test_sav.py

@@ -0,0 +1,135 @@
+from tests.integration.integration_test_case import IntegrationTestCase
+from tests.integration.it_utils import (
+    fund_wallet_async,
+    sign_and_reliable_submission_async,
+    test_async_and_sync,
+)
+from tests.integration.reusable_values import WALLET
+from xrpl.models import (
+    Payment,
+    TrustSet,
+    VaultClawback,
+    VaultCreate,
+    VaultDelete,
+    VaultDeposit,
+    VaultSet,
+    VaultWithdraw,
+)
+from xrpl.models.amounts.issued_currency_amount import IssuedCurrencyAmount
+from xrpl.models.currencies import IssuedCurrency
+from xrpl.models.requests import AccountObjects
+from xrpl.models.requests.account_objects import AccountObjectType
+from xrpl.models.response import ResponseStatus
+from xrpl.utils import str_to_hex
+from xrpl.wallet import Wallet
+
+
+class TestSingleAssetVault(IntegrationTestCase):
+    @test_async_and_sync(globals())
+    async def test_sav_lifecycle(self, client):
+
+        vault_owner = Wallet.create()
+        await fund_wallet_async(vault_owner)
+
+        issuer_wallet = Wallet.create()
+        await fund_wallet_async(issuer_wallet)
+
+        # Step-0.a: Prerequisites: Set up the IOU trust line
+        tx = TrustSet(
+            account=WALLET.address,
+            limit_amount=IssuedCurrencyAmount(
+                currency="USD", issuer=issuer_wallet.address, value="1000"
+            ),
+        )
+        response = await sign_and_reliable_submission_async(tx, WALLET, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-0.b: Send the payment of IOUs from issuer_wallet to WALLET
+        tx = Payment(
+            account=issuer_wallet.address,
+            amount=IssuedCurrencyAmount(
+                currency="USD", issuer=issuer_wallet.address, value="1000"
+            ),
+            destination=WALLET.address,
+        )
+        response = await sign_and_reliable_submission_async(tx, issuer_wallet, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-1: Create a vault
+        tx = VaultCreate(
+            account=vault_owner.address,
+            asset=IssuedCurrency(currency="USD", issuer=issuer_wallet.address),
+            asset_maximum="1000",
+            withdrawal_policy=1,
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Verify the existence of the vault with account_objects RPC call
+        account_objects_response = await client.request(
+            AccountObjects(account=vault_owner.address, type=AccountObjectType.VAULT)
+        )
+        self.assertEqual(len(account_objects_response.result["account_objects"]), 1)
+
+        VAULT_ID = account_objects_response.result["account_objects"][0]["index"]
+
+        # Step-2: Update the characteristics of the vault with VaultSet transaction
+        tx = VaultSet(
+            account=vault_owner.address,
+            vault_id=VAULT_ID,
+            data=str_to_hex("auxilliary data pertaining to the vault"),
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-3: Execute a VaultDeposit transaction
+        tx = VaultDeposit(
+            account=WALLET.address,
+            vault_id=VAULT_ID,
+            amount=IssuedCurrencyAmount(
+                currency="USD", issuer=issuer_wallet.address, value="10"
+            ),
+        )
+        response = await sign_and_reliable_submission_async(tx, WALLET, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-4: Execute a VaultWithdraw transaction
+        tx = VaultWithdraw(
+            account=WALLET.address,
+            vault_id=VAULT_ID,
+            amount=IssuedCurrencyAmount(
+                currency="USD", issuer=issuer_wallet.address, value="9"
+            ),
+        )
+        response = await sign_and_reliable_submission_async(tx, WALLET, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-5: Execute a VaultClawback transaction from issuer_wallet
+        tx = VaultClawback(
+            holder=WALLET.address,
+            account=issuer_wallet.address,
+            vault_id=VAULT_ID,
+            # Note: Although the amount is specified as 9, 1 unit of the IOU will be
+            # clawed back, because that is the remaining balance in the vault
+            amount=IssuedCurrencyAmount(
+                currency="USD", issuer=issuer_wallet.address, value="9"
+            ),
+        )
+        response = await sign_and_reliable_submission_async(tx, issuer_wallet, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-6: Delete the Vault with VaultDelete transaction
+        tx = VaultDelete(
+            account=vault_owner.address,
+            vault_id=VAULT_ID,
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")

tests/unit/core/binarycodec/types/test_number.py

@@ -0,0 +1,46 @@
+import unittest
+
+from xrpl.core.binarycodec.types.number import Number
+
+
+class TestNumber(unittest.TestCase):
+    def test_serialization_and_deserialization(self):
+        serialized_number = Number.from_value("124")
+        self.assertEqual(serialized_number.to_json(), "124")
+
+        serialized_number = Number.from_value("1000")
+        self.assertEqual(serialized_number.to_json(), "1000")
+
+        serialized_number = Number.from_value("0")
+        self.assertEqual(serialized_number.to_json(), "0")
+
+        serialized_number = Number.from_value("-1")
+        self.assertEqual(serialized_number.to_json(), "-1")
+
+        serialized_number = Number.from_value("-10")
+        self.assertEqual(serialized_number.to_json(), "-10")
+
+        serialized_number = Number.from_value("123.456")
+        self.assertEqual(serialized_number.to_json(), "123.456")
+
+        serialized_number = Number.from_value("1.456e-45")
+        self.assertEqual(serialized_number.to_json(), "1456000000000000e-60")
+
+        serialized_number = Number.from_value("0.456e34")
+        self.assertEqual(serialized_number.to_json(), "4560000000000000e18")
+
+        serialized_number = Number.from_value("4e34")
+        self.assertEqual(serialized_number.to_json(), "4000000000000000e19")
+
+    def test_extreme_limits(self):
+        lowest_mantissa = "-9223372036854776"
+        serialized_number = Number.from_value(lowest_mantissa + "e3")
+        self.assertEqual(
+            serialized_number.display_serialized_hex(), "FFDF3B645A1CAC0800000003"
+        )
+
+        highest_mantissa = "9223372036854776"
+        serialized_number = Number.from_value(highest_mantissa + "e3")
+        self.assertEqual(
+            serialized_number.display_serialized_hex(), "0020C49BA5E353F800000003"
+        )

xrpl/asyncio/transaction/main.py

@@ -483,6 +483,7 @@ async def _calculate_fee_per_transaction_type(
     if transaction.transaction_type in (
         TransactionType.ACCOUNT_DELETE,
         TransactionType.AMM_CREATE,
+        TransactionType.VAULT_CREATE,
     ):
         base_fee = await _fetch_owner_reserve_fee(client)
 

xrpl/core/binarycodec/definitions/definitions.json

@@ -1260,6 +1260,16 @@
         "type": "Hash256"
       }
     ],
+    [
+      "VaultID",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 35,
+        "type": "Hash256"
+      }
+    ],
     [
       "hash",
       {
@@ -2030,6 +2040,56 @@
         "type": "AccountID"
       }
     ],
+    [
+      "Number",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 1,
+        "type": "Number"
+      }
+    ],
+    [
+      "AssetAvailable",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 2,
+        "type": "Number"
+      }
+    ],
+    [
+      "AssetMaximum",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 3,
+        "type": "Number"
+      }
+    ],
+    [
+      "AssetTotal",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 4,
+        "type": "Number"
+      }
+    ],
+    [
+      "LossUnrealized",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 5,
+        "type": "Number"
+      }
+    ],
     [
       "TransactionMetaData",
       {
@@ -2639,6 +2699,16 @@
         "type": "UInt8"
       }
     ],
+    [
+      "WithdrawalPolicy",
+      {
+        "isSerialized": true,
+        "isSigningField": true,
+        "isVLEncoded": false,
+        "nth": 20,
+        "type": "UInt8"
+      }
+    ],
     [
       "TakerPaysCurrency",
       {
@@ -2886,6 +2956,7 @@
     "RippleState": 114,
     "SignerList": 83,
     "Ticket": 84,
+    "Vault" : 131,
     "XChainOwnedClaimID": 113,
     "XChainOwnedCreateAccountClaimID": 116
   },
@@ -3123,6 +3194,12 @@
     "TicketCreate": 10,
     "TrustSet": 20,
     "UNLModify": 102,
+    "VaultCreate": 64,
+    "VaultClawback": 69,
+    "VaultDeposit": 67,
+    "VaultDelete": 66,
+    "VaultSet": 65,
+    "VaultWithdraw": 68,
     "XChainAccountCreateCommit": 44,
     "XChainAddAccountCreateAttestation": 46,
     "XChainAddClaimAttestation": 45,
@@ -3146,6 +3223,7 @@
     "LedgerEntry": 10002,
     "Metadata": 10004,
     "NotPresent": 0,
+    "Number": 9,
     "PathSet": 18,
     "STArray": 15,
     "STObject": 14,

xrpl/core/binarycodec/types/__init__.py

@@ -10,6 +10,7 @@
 from xrpl.core.binarycodec.types.hash192 import Hash192
 from xrpl.core.binarycodec.types.hash256 import Hash256
 from xrpl.core.binarycodec.types.issue import Issue
+from xrpl.core.binarycodec.types.number import Number
 from xrpl.core.binarycodec.types.path_set import PathSet
 from xrpl.core.binarycodec.types.st_array import STArray
 from xrpl.core.binarycodec.types.st_object import STObject
@@ -32,6 +33,7 @@
     "Hash192",
     "Hash256",
     "Issue",
+    "Number",
     "PathSet",
     "STObject",
     "STArray",