PermissionedDomain XLS-80d

packages/ripple-binary-codec/src/enums/definitions.json

@@ -1250,6 +1250,16 @@
         "type": "Hash256"
       }
     ],
+    [
+      "DomainID",
+      {
+        "nth": 34,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
     [
       "hash",
       {
@@ -2530,6 +2540,15 @@
         "type": "STArray"
       }
     ],
+    [
+      "AcceptedCredentials", {
+        "nth": 28,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
+    ],
     [
       "CloseResolution",
       {
@@ -2863,6 +2882,7 @@
     "Oracle": 128,
     "Credential": 129,
     "PayChannel": 120,
+    "PermissionedDomain": 130,
     "RippleState": 114,
     "SignerList": 83,
     "Ticket": 84,
@@ -3093,6 +3113,8 @@
     "PaymentChannelClaim": 15,
     "PaymentChannelCreate": 13,
     "PaymentChannelFund": 14,
+    "PermissionedDomainSet": 61,
+    "PermissionedDomainDelete": 62,
     "SetFee": 101,
     "SetRegularKey": 5,
     "SignerListSet": 12,

packages/xrpl/HISTORY.md

@@ -4,6 +4,9 @@ Subscribe to [the **xrpl-announce** mailing list](https://groups.google.com/g/xr
 
 ## Unreleased Changes
 
+### Added
+* Implementation of XLS-80d PermissionedDomain feature.
+
 ## 4.1.0 (2024-12-23)
 
 ### Added

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

@@ -13,6 +13,7 @@ import NegativeUNL from './NegativeUNL'
 import Offer from './Offer'
 import Oracle from './Oracle'
 import PayChannel from './PayChannel'
+import PermissionedDomain from './PermissionedDomain'
 import RippleState from './RippleState'
 import SignerList from './SignerList'
 import Ticket from './Ticket'
@@ -35,6 +36,7 @@ type LedgerEntry =
   | Offer
   | Oracle
   | PayChannel
+  | PermissionedDomain
   | RippleState
   | SignerList
   | Ticket
@@ -61,6 +63,7 @@ type LedgerEntryFilter =
   | 'offer'
   | 'oracle'
   | 'payment_channel'
+  | 'permissioned_domain'
   | 'signer_list'
   | 'state'
   | 'ticket'

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

@@ -0,0 +1,24 @@
+import { BaseLedgerEntry, HasPreviousTxnID } from './BaseLedgerEntry'
+
+export interface Credential {
+  Credential: {
+    Issuer: string
+    CredentialType: string
+  }
+}
+
+export default interface PermissionedDomain
+  extends BaseLedgerEntry,
+    HasPreviousTxnID {
+  LedgerEntryType: 'PermissionedDomain'
+
+  Owner: string
+
+  Flags: 0
+
+  OwnerNode: string
+
+  Sequence: number
+
+  AcceptedCredentials: Credential[]
+}

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

@@ -105,3 +105,6 @@ export {
   XChainModifyBridgeFlags,
   XChainModifyBridgeFlagsInterface,
 } from './XChainModifyBridge'
+
+export { PermissionedDomainSet } from './permissionedDomainSet'
+export { PermissionedDomainDelete } from './permissionedDomainDelete'

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

@@ -0,0 +1,18 @@
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField
+} from './common'
+
+export interface PermissionedDomainDelete extends BaseTransaction {
+  TransactionType: 'PermissionedDomainDelete'
+
+  DomainID: string
+}
+
+export function validatePermissionedDomainDelete(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'DomainID', isString)
+}

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

@@ -0,0 +1,47 @@
+import { ValidationError } from '../../errors'
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+import { Credential } from '../ledger/PermissionedDomain'
+const ACCEPTED_CREDENTIALS_MAX_LENGTH = 10
+
+export interface PermissionedDomainSet extends BaseTransaction {
+  TransactionType: 'PermissionedDomainSet'
+
+  DomainID?: string
+  AcceptedCredentials: Credential[]
+}
+
+// eslint-disable-next-line max-lines-per-function -- necessary to validate many fields
+export function validatePermissionedDomainSet(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateOptionalField(tx, 'DomainID', isString)
+
+  // eslint-disable-next-line max-lines-per-function -- necessary to validate many fields
+  validateRequiredField(tx, 'AcceptedCredentials', (value) => {
+    if (!Array.isArray(value)) {
+      throw new ValidationError('PermissionedDomainSet: AcceptedCredentials must be an array')
+    }
+
+    if (value.length > ACCEPTED_CREDENTIALS_MAX_LENGTH) {
+      throw new ValidationError(
+        `PermissionedDomainSet: AcceptedCredentials must have at most ${ACCEPTED_CREDENTIALS_MAX_LENGTH} Credential objects`,
+      )
+    }
+    else if (value.length === 0) {
+      throw new ValidationError(
+        `PermissionedDomainSet: AcceptedCredentials must have at least one Credential object`,
+      )
+    }
+
+    // Note: This implementation does not rigorously validate the inner-object format of AcceptedCredentials array because that would be a blatant repetition of the rippled cpp implementation.
+
+    return true
+  })
+}

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

@@ -74,6 +74,8 @@ import {
   PaymentChannelFund,
   validatePaymentChannelFund,
 } from './paymentChannelFund'
+import { PermissionedDomainDelete, validatePermissionedDomainDelete } from './permissionedDomainDelete'
+import { PermissionedDomainSet, validatePermissionedDomainSet } from './permissionedDomainSet'
 import { SetFee } from './setFee'
 import { SetRegularKey, validateSetRegularKey } from './setRegularKey'
 import { SignerListSet, validateSignerListSet } from './signerListSet'
@@ -151,6 +153,8 @@ export type SubmittableTransaction =
   | PaymentChannelClaim
   | PaymentChannelCreate
   | PaymentChannelFund
+  | PermissionedDomainSet
+  | PermissionedDomainDelete
   | SetRegularKey
   | SignerListSet
   | TicketCreate
@@ -409,6 +413,14 @@ export function validate(transaction: Record<string, unknown>): void {
       validatePaymentChannelFund(tx)
       break
 
+    case 'PermissionedDomainSet':
+      validatePermissionedDomainSet(tx)
+      break
+
+    case 'PermissionedDomainDelete':
+      validatePermissionedDomainDelete(tx)
+      break
+
     case 'SetRegularKey':
       validateSetRegularKey(tx)
       break

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

@@ -0,0 +1,79 @@
+import { stringToHex } from '@xrplf/isomorphic/utils'
+import { assert } from 'chai'
+
+import { LedgerEntryRequest, PermissionedDomainDelete, PermissionedDomainSet } from '../../../src'
+import PermissionedDomain, { Credential } from '../../../src/models/ledger/PermissionedDomain'
+import serverUrl from '../serverUrl'
+import {
+  setupClient,
+  teardownClient,
+  type XrplIntegrationTestContext,
+} from '../setup'
+import { testTransaction } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('PermissionedDomainSet', function () {
+  let testContext: XrplIntegrationTestContext
+
+  beforeEach(async () => {
+    testContext = await setupClient(serverUrl)
+  })
+  afterEach(async () => teardownClient(testContext))
+
+  it(
+    'Lifecycle of PermissionedDomain ledger object',
+    async () => {
+      const sampleCredential: Credential = {
+        Credential: {
+          CredentialType: stringToHex('Passport'),
+          Issuer: testContext.wallet.classicAddress
+        }
+      }
+
+      // Step-1: Test the PermissionedDomainSet transaction
+      const tx_pd_set: PermissionedDomainSet = {
+        TransactionType: 'PermissionedDomainSet',
+        Account: testContext.wallet.classicAddress,
+        AcceptedCredentials: [sampleCredential]
+      }
+
+      await testTransaction(testContext.client, tx_pd_set, testContext.wallet)
+
+      // Step-2: Validate the ledger_entry, account_objects RPC methods
+      // validate the account_objects RPC
+      const result = await testContext.client.request({
+        command: 'account_objects',
+        account: testContext.wallet.classicAddress,
+        type: 'permissioned_domain',
+      })
+
+      assert.equal(result.result.account_objects.length, 1)
+      const pd = result.result.account_objects[0] as PermissionedDomain
+
+      assert.equal(pd.Flags, 0)
+      expect(pd.AcceptedCredentials).toEqual([sampleCredential])
+
+      // validate the ledger_entry RPC
+      const ledger_entry_request: LedgerEntryRequest = {
+        command: 'ledger_entry',
+        // fetch the PD `index` from the previous account_objects RPC response
+        index: pd.index
+      }
+      const ledger_entry_result = await testContext.client.request(ledger_entry_request)
+      assert.deepEqual(pd, ledger_entry_result.result.node)
+
+      // Step-3: Test the PDDelete transaction
+      const tx_pd_delete: PermissionedDomainDelete = {
+        TransactionType: 'PermissionedDomainDelete',
+        Account: testContext.wallet.classicAddress,
+        // fetch the PD `index` from the previous account_objects RPC response
+        DomainID: pd.index
+      }
+
+      await testTransaction(testContext.client, tx_pd_delete, testContext.wallet)
+    },
+    TIMEOUT,
+  )
+})

packages/xrpl/test/models/permissionedDomainDelete.test.ts

@@ -0,0 +1,40 @@
+import { assert } from 'chai'
+
+import { validate, ValidationError } from '../../src'
+import { validatePermissionedDomainDelete } from '../../src/models/transactions/permissionedDomainDelete'
+
+/**
+ * PermissionedDomainDelete Transaction Verification Testing.
+ *
+ * Providing runtime verification testing for each specific transaction type.
+ */
+describe('PermissionedDomainDelete', function () {
+  let tx
+
+  beforeEach(function () {
+    tx = {
+      TransactionType: 'PermissionedDomainDelete',
+      Account: 'rfmDuhDyLGgx94qiwf3YF8BUV5j6KSvE8',
+      DomainID: 'D88930B33C2B6831660BFD006D91FF100011AD4E67CBB78B460AF0A215103737',
+    } as any
+  })
+
+  it('verifies valid PermissionedDomainDelete', function () {
+    assert.doesNotThrow(() => validatePermissionedDomainDelete(tx))
+    assert.doesNotThrow(() => validate(tx))
+  })
+
+  it(`throws w/ missing field DomainID`, function () {
+    delete tx.DomainID
+    const errorMessage = 'PermissionedDomainDelete: missing field DomainID'
+    assert.throws(() => validatePermissionedDomainDelete(tx), ValidationError, errorMessage)
+    assert.throws(() => validate(tx), ValidationError, errorMessage)
+  })
+
+  it(`throws w/ invalid DomainID`, function () {
+    tx.DomainID = 1234
+    const errorMessage = 'PermissionedDomainDelete: invalid field DomainID'
+    assert.throws(() => validatePermissionedDomainDelete(tx), ValidationError, errorMessage)
+    assert.throws(() => validate(tx), ValidationError, errorMessage)
+  })
+})