Deep Freeze XLS-77d

.ci-config/rippled.cfg

@@ -188,3 +188,4 @@ fixNFTokenPageLinks
 fixInnerObjTemplate2
 fixEnforceNFTokenTrustline
 fixReducedOffersV2
+DeepFreeze

packages/xrpl/HISTORY.md

@@ -10,6 +10,9 @@ Subscribe to [the **xrpl-announce** mailing list](https://groups.google.com/g/xr
 ### Changed
 * Deprecated `setTransactionFlagsToNumber`. Start using convertTxFlagsToNumber instead
 
+### Added
+* Support for XLS-77d Deep-Freeze amendment
+
 ## 4.1.0 (2024-12-23)
 
 ### Added

packages/xrpl/src/models/ledger/RippleState.ts

@@ -77,4 +77,8 @@ export enum RippleStateFlags {
   lsfHighFreeze = 0x00800000,
   // True, trust line to AMM. Used by client apps to identify payments via AMM.
   lsfAMMNode = 0x01000000,
+  // True, low side has set deep freeze flag
+  lsfLowDeepFreeze = 0x02000000,
+  // True, high side has set deep freeze flag
+  lsfHighDeepFreeze = 0x04000000,
 }

packages/xrpl/src/models/transactions/trustSet.ts

@@ -30,6 +30,11 @@ export enum TrustSetFlags {
   tfSetFreeze = 0x00100000,
   /** Unfreeze the trust line. */
   tfClearFreeze = 0x00200000,
+  /** Deep-Freeze the trustline -- disallow sending and receiving the said IssuedCurrency */
+  /** Allowed only if the trustline is already regularly frozen, or if tfSetFreeze is set in the same transaction. */
+  tfSetDeepFreeze = 0x00400000,
+  /** Clear a Deep-Frozen trustline */
+  tfClearDeepFreeze = 0x00800000,
 }
 
 /**
@@ -89,6 +94,11 @@ export interface TrustSetFlagsInterface extends GlobalFlags {
   tfSetFreeze?: boolean
   /** Unfreeze the trust line. */
   tfClearFreeze?: boolean
+  /** Deep-Freeze the trustline -- disallow sending and receiving the said IssuedCurrency */
+  /** Allowed only if the trustline is already regularly frozen, or if tfSetFreeze is set in the same transaction. */
+  tfSetDeepFreeze?: boolean
+  /** Clear a Deep-Frozen trust line */
+  tfClearDeepFreeze?: boolean
 }
 
 /**

packages/xrpl/test/integration/transactions/offerCreate.test.ts

@@ -1,24 +1,36 @@
 import { assert } from 'chai'
 
-import { OfferCreate } from '../../../src'
+import { OfferCreate, TrustSet, Wallet } from '../../../src'
 import serverUrl from '../serverUrl'
 import {
   setupClient,
   teardownClient,
   type XrplIntegrationTestContext,
 } from '../setup'
-import { testTransaction } from '../utils'
+import {
+  testTransaction,
+  generateFundedWallet,
+  submitTransaction,
+} from '../utils'
 
 // how long before each test case times out
 const TIMEOUT = 20000
 
 describe('OfferCreate', function () {
   let testContext: XrplIntegrationTestContext
+  let wallet_deep_freeze_trustline: Wallet | undefined
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     testContext = await setupClient(serverUrl)
+    if (!wallet_deep_freeze_trustline) {
+      // eslint-disable-next-line require-atomic-updates -- race condition doesn't really matter
+      wallet_deep_freeze_trustline = await generateFundedWallet(
+        testContext.client,
+      )
+    }
   })
-  afterEach(async () => teardownClient(testContext))
+
+  afterAll(async () => teardownClient(testContext))
 
   it(
     'base',
@@ -49,4 +61,52 @@ describe('OfferCreate', function () {
     },
     TIMEOUT,
   )
+
+  it(
+    'OfferCreate with Deep-Frozen trustline must fail',
+    async () => {
+      assert(wallet_deep_freeze_trustline != null)
+
+      // deep-freeze the trust line
+      const trust_set_tx: TrustSet = {
+        TransactionType: 'TrustSet',
+        Account: testContext.wallet.classicAddress,
+        LimitAmount: {
+          currency: 'USD',
+          issuer: wallet_deep_freeze_trustline.classicAddress,
+          value: '10',
+        },
+        Flags: {
+          tfSetFreeze: true,
+          tfSetDeepFreeze: true,
+        },
+      }
+
+      await testTransaction(
+        testContext.client,
+        trust_set_tx,
+        testContext.wallet,
+      )
+
+      const offer_create_tx: OfferCreate = {
+        TransactionType: 'OfferCreate',
+        Account: testContext.wallet.classicAddress,
+        TakerGets: '13100000',
+        TakerPays: {
+          currency: 'USD',
+          issuer: wallet_deep_freeze_trustline.classicAddress,
+          value: '10',
+        },
+      }
+
+      const response = await submitTransaction({
+        client: testContext.client,
+        transaction: offer_create_tx,
+        wallet: testContext.wallet,
+      })
+
+      assert.equal(response.result.engine_result, 'tecFROZEN')
+    },
+    TIMEOUT,
+  )
 })

packages/xrpl/test/integration/transactions/trustSet.test.ts

@@ -1,14 +1,14 @@
 import { assert } from 'chai'
 
-import { TrustSet, percentToQuality, Wallet } from '../../../src'
+import { TrustSet, percentToQuality, Wallet, TrustSetFlags } from '../../../src'
 import serverUrl from '../serverUrl'
 import {
   setupClient,
   teardownClient,
   type XrplIntegrationTestContext,
 } from '../setup'
 import { generateFundedWallet, testTransaction } from '../utils'
-
+import RippleState from '../../../src/models/ledger/RippleState'
 // how long before each test case times out
 const TIMEOUT = 20000
 
@@ -85,4 +85,49 @@ describe('TrustSet', function () {
     },
     TIMEOUT,
   )
+
+  it(
+    'Create a Deep-Frozen trustline',
+    async () => {
+      assert(wallet2 != null)
+      // deep-freeze a trustline with the specified counter-party/currency-code
+      const tx: TrustSet = {
+        TransactionType: 'TrustSet',
+        Account: testContext.wallet.classicAddress,
+        LimitAmount: {
+          currency: 'USD',
+          issuer: wallet2.classicAddress,
+          value: '10',
+        },
+        Flags: {
+          tfSetFreeze: true,
+          tfSetDeepFreeze: true,
+        },
+      }
+
+      const response = await testTransaction(
+        testContext.client,
+        tx,
+        testContext.wallet,
+      )
+      assert.equal(response.result.engine_result, 'tesSUCCESS')
+
+      // assert that the trustline is frozen
+      const trustLine = await testContext.client.request({
+        command: 'account_lines',
+        account: testContext.wallet.classicAddress,
+      })
+      assert.equal(trustLine.result.lines[0].freeze, true)
+
+      // verify that the trust-line is deep-frozen
+      // this operation cannot be done with the account_lines RPC
+      const account_objects = await testContext.client.request({
+        command: 'account_objects',
+        account: testContext.wallet.classicAddress,
+      })
+      assert.isTrue(((account_objects.result.account_objects[0] as RippleState).Flags & TrustSetFlags.tfSetDeepFreeze) != 0)
+
+    },
+    TIMEOUT,
+  )
 })

packages/xrpl/test/models/trustSet.test.ts

@@ -22,6 +22,11 @@ describe('TrustSet', function () {
       },
       QualityIn: 1234,
       QualityOut: 4321,
+      // an example of deep-frozen trustline
+      Flags: {
+        tfSetFreeze: true,
+        tfSetDeepFreeze: true,
+      },
     } as any
   })