Deep Freeze XLS-77d (#2873)

.ci-config/rippled.cfg

@@ -63,17 +63,10 @@ online_delete=256
 [debug_logfile]
 /var/log/rippled/debug.log
 
-[sntp_servers]
-time.windows.com
-time.apple.com
-time.nist.gov
-pool.ntp.org
 
 [ips]
 r.ripple.com 51235
 
-[validators_file]
-validators.txt
 
 [rpc_startup]
 { "command": "log_level", "severity": "info" }
@@ -188,5 +181,6 @@ fixNFTokenPageLinks
 fixInnerObjTemplate2
 fixEnforceNFTokenTrustline
 fixReducedOffersV2
+DeepFreeze
 DynamicNFT
 PermissionedDomains

packages/xrpl/HISTORY.md

@@ -8,6 +8,7 @@ Subscribe to [the **xrpl-announce** mailing list](https://groups.google.com/g/xr
 * Adds utility function `convertTxFlagsToNumber`
 * Implementation of XLS-80d PermissionedDomain feature.
 * Support for the `simulate` RPC ([XLS-69](https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0069-simulate))
+* Support for XLS-77d Deep-Freeze amendment
 
 ### Changed
 * Deprecated `setTransactionFlagsToNumber`. Start using convertTxFlagsToNumber instead

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,6 +1,8 @@
 import { assert } from 'chai'
 
 import { TrustSet, percentToQuality, Wallet } from '../../../src'
+import { RippleState } from '../../../src/models/ledger/index'
+import { RippleStateFlags } from '../../../src/models/ledger/RippleState'
 import serverUrl from '../serverUrl'
 import {
   setupClient,
@@ -85,4 +87,60 @@ 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,
+      })
+
+      const rippleState = account_objects.result
+        .account_objects[0] as RippleState
+
+      // Depending on the pseudo-random generation of accounts,
+      // either of the below leger-object flags must be set
+
+      const hasDeepFreeze =
+        // eslint-disable-next-line no-bitwise -- required to validate flag
+        (rippleState.Flags & RippleStateFlags.lsfHighDeepFreeze) |
+        // eslint-disable-next-line no-bitwise -- required to validate flag
+        (rippleState.Flags & RippleStateFlags.lsfLowDeepFreeze)
+      assert.isTrue(hasDeepFreeze !== 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
   })