xrpl 4.3.0 → 4.4.0

package/src/models/transactions/oracleSet.ts

@@ -4,7 +4,9 @@ import { isHex } from '../utils'
 
 import {
   BaseTransaction,
+  isArray,
   isNumber,
+  isRecord,
   isString,
   validateBaseTransaction,
   validateOptionalField,
@@ -90,7 +92,7 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
     tx,
     'PriceDataSeries',
     (value: unknown): value is PriceData => {
-      if (!Array.isArray(value)) {
+      if (!isArray(value)) {
         throw new ValidationError('OracleSet: PriceDataSeries must be an array')
       }
 
@@ -102,14 +104,15 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
 
       // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
       for (const priceData of value) {
-        if (typeof priceData !== 'object') {
+        if (!isRecord(priceData)) {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must be an array of objects',
           )
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        if (priceData.PriceData == null) {
+        const priceDataInner = priceData.PriceData
+
+        if (!isRecord(priceDataInner)) {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have a `PriceData` object',
           )
@@ -122,15 +125,16 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
           )
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        if (typeof priceData.PriceData.BaseAsset !== 'string') {
+        if (
+          priceDataInner.BaseAsset == null ||
+          typeof priceDataInner.BaseAsset !== 'string'
+        ) {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have a `BaseAsset` string',
           )
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-        if (typeof priceData.PriceData.QuoteAsset !== 'string') {
+        if (typeof priceDataInner.QuoteAsset !== 'string') {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
           )
@@ -138,34 +142,31 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
 
         // Either AssetPrice and Scale are both present or both excluded
         if (
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          (priceData.PriceData.AssetPrice == null) !==
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          (priceData.PriceData.Scale == null)
+          (priceDataInner.AssetPrice == null) !==
+          (priceDataInner.Scale == null)
         ) {
           throw new ValidationError(
             'OracleSet: PriceDataSeries must have both `AssetPrice` and `Scale` if any are present',
           )
         }
 
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access, max-depth --
-      we need to validate priceData.PriceData.AssetPrice value */
-        if ('AssetPrice' in priceData.PriceData) {
-          if (!isNumber(priceData.PriceData.AssetPrice)) {
-            if (typeof priceData.PriceData.AssetPrice !== 'string') {
+        /* eslint-disable max-depth --
+      we need to validate priceDataInner.AssetPrice value */
+        if ('AssetPrice' in priceDataInner) {
+          if (!isNumber(priceDataInner.AssetPrice)) {
+            if (typeof priceDataInner.AssetPrice !== 'string') {
               throw new ValidationError(
                 'OracleSet: Field AssetPrice must be a string or a number',
               )
             }
-            if (!isHex(priceData.PriceData.AssetPrice)) {
+            if (!isHex(priceDataInner.AssetPrice)) {
               throw new ValidationError(
                 'OracleSet: Field AssetPrice must be a valid hex string',
               )
             }
             if (
-              priceData.PriceData.AssetPrice.length <
-                MINIMUM_ASSET_PRICE_LENGTH ||
-              priceData.PriceData.AssetPrice.length > MAXIMUM_ASSET_PRICE_LENGTH
+              priceDataInner.AssetPrice.length < MINIMUM_ASSET_PRICE_LENGTH ||
+              priceDataInner.AssetPrice.length > MAXIMUM_ASSET_PRICE_LENGTH
             ) {
               throw new ValidationError(
                 `OracleSet: Length of AssetPrice field must be between ${MINIMUM_ASSET_PRICE_LENGTH} and ${MAXIMUM_ASSET_PRICE_LENGTH} characters long`,
@@ -173,26 +174,18 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
             }
           }
         }
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access, max-depth */
 
-        if (
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          'Scale' in priceData.PriceData &&
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          !isNumber(priceData.PriceData.Scale)
-        ) {
-          throw new ValidationError('OracleSet: invalid field Scale')
-        }
+        if ('Scale' in priceDataInner) {
+          if (!isNumber(priceDataInner.Scale)) {
+            throw new ValidationError('OracleSet: invalid field Scale')
+          }
 
-        if (
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          priceData.PriceData.Scale < 0 ||
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-          priceData.PriceData.Scale > SCALE_MAX
-        ) {
-          throw new ValidationError(
-            `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
-          )
+          if (priceDataInner.Scale < 0 || priceDataInner.Scale > SCALE_MAX) {
+            throw new ValidationError(
+              `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
+            )
+          }
+          /* eslint-enable max-depth */
         }
       }
       return true

package/src/models/transactions/payment.ts

@@ -8,12 +8,14 @@ import {
   GlobalFlagsInterface,
   validateBaseTransaction,
   isAccount,
+  isDomainID,
   validateRequiredField,
   validateOptionalField,
   isNumber,
   Account,
   validateCredentialsList,
   MAX_AUTHORIZED_CREDENTIALS,
+  isArray,
 } from './common'
 import type { TransactionMetadataBase } from './metadata'
 
@@ -119,6 +121,9 @@ export interface Payment extends BaseTransaction {
    * to this amount instead.
    */
   Amount: Amount | MPTAmount
+
+  DeliverMax?: Amount | MPTAmount
+
   /** The unique address of the account receiving the payment. */
   Destination: Account
   /**
@@ -156,6 +161,18 @@ export interface Payment extends BaseTransaction {
    * The credentials included must not be expired.
    */
   CredentialIDs?: string[]
+  /**
+   * The domain the sender intends to use. Both the sender and destination must
+   * be part of this domain. The DomainID can be included if the sender intends
+   * it to be a cross-currency payment (i.e. if the payment is going to interact
+   * with the DEX). The domain will only play it's role if there is a path that
+   * crossing an orderbook.
+   *
+   * Note: it's still possible that DomainID is included but the payment does
+   * not interact with DEX, it simply means that the DomainID will be ignored
+   * during payment paths.
+   */
+  DomainID?: string
   Flags?: number | PaymentFlagsInterface
 }
 
@@ -195,11 +212,12 @@ export function validatePayment(tx: Record<string, unknown>): void {
     throw new ValidationError('PaymentTransaction: InvoiceID must be a string')
   }
 
-  if (
-    tx.Paths !== undefined &&
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
-    !isPaths(tx.Paths as Array<Array<Record<string, unknown>>>)
-  ) {
+  validateOptionalField(tx, 'DomainID', isDomainID, {
+    txType: 'PaymentTransaction',
+    paramName: 'DomainID',
+  })
+
+  if (tx.Paths !== undefined && !isPaths(tx.Paths)) {
     throw new ValidationError('PaymentTransaction: invalid Paths')
   }
 
@@ -276,12 +294,12 @@ function isPath(path: unknown): path is Path {
 }
 
 function isPaths(paths: unknown): paths is Path[] {
-  if (!Array.isArray(paths) || paths.length === 0) {
+  if (!isArray(paths) || paths.length === 0) {
     return false
   }
 
   for (const path of paths) {
-    if (!Array.isArray(path) || path.length === 0) {
+    if (!isArray(path) || path.length === 0) {
       return false
     }
 

package/src/models/transactions/signerListSet.ts

@@ -1,7 +1,15 @@
 import { ValidationError } from '../../errors'
 import { SignerEntry } from '../common'
 
-import { BaseTransaction, isArray, validateBaseTransaction } from './common'
+import {
+  BaseTransaction,
+  isArray,
+  isNumber,
+  isRecord,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField,
+} from './common'
 
 /**
  * The SignerListSet transaction creates, replaces, or removes a list of
@@ -39,27 +47,14 @@ const HEX_WALLET_LOCATOR_REGEX = /^[0-9A-Fa-f]{64}$/u
 export function validateSignerListSet(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.SignerQuorum === undefined) {
-    throw new ValidationError('SignerListSet: missing field SignerQuorum')
-  }
-
-  if (typeof tx.SignerQuorum !== 'number') {
-    throw new ValidationError('SignerListSet: invalid SignerQuorum')
-  }
+  validateRequiredField(tx, 'SignerQuorum', isNumber)
 
   // All other checks are for if SignerQuorum is greater than 0
   if (tx.SignerQuorum === 0) {
     return
   }
 
-  if (tx.SignerEntries === undefined) {
-    throw new ValidationError('SignerListSet: missing field SignerEntries')
-  }
-
-  if (!isArray(tx.SignerEntries)) {
-    throw new ValidationError('SignerListSet: invalid SignerEntries')
-  }
-
+  validateRequiredField(tx, 'SignerEntries', isArray)
   if (tx.SignerEntries.length === 0) {
     throw new ValidationError(
       'SignerListSet: need at least 1 member in SignerEntries',
@@ -73,12 +68,17 @@ export function validateSignerListSet(tx: Record<string, unknown>): void {
   }
 
   for (const entry of tx.SignerEntries) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be a SignerEntry
-    const signerEntry = entry as SignerEntry
-    const { WalletLocator } = signerEntry.SignerEntry
+    if (!isRecord(entry) || !isRecord(entry.SignerEntry)) {
+      throw new ValidationError(
+        'SignerListSet: SignerEntries must be an array of SignerEntry objects',
+      )
+    }
+    const signerEntry = entry.SignerEntry
+    const { WalletLocator } = signerEntry
     if (
-      WalletLocator !== undefined &&
-      !HEX_WALLET_LOCATOR_REGEX.test(WalletLocator)
+      WalletLocator != null &&
+      (!isString(WalletLocator) ||
+        !HEX_WALLET_LOCATOR_REGEX.test(WalletLocator))
     ) {
       throw new ValidationError(
         `SignerListSet: WalletLocator in SignerEntry must be a 256-bit (32-byte) hexadecimal value`,

package/src/models/transactions/transaction.ts

@@ -2,8 +2,6 @@
 /* eslint-disable max-lines-per-function -- need to work with a lot of Tx verifications */
 
 import { ValidationError } from '../../errors'
-import { IssuedCurrencyAmount, Memo } from '../common'
-import { isHex } from '../utils'
 import { convertTxFlagsToNumber } from '../utils/flags'
 
 import { AccountDelete, validateAccountDelete } from './accountDelete'
@@ -20,7 +18,11 @@ import { CheckCancel, validateCheckCancel } from './checkCancel'
 import { CheckCash, validateCheckCash } from './checkCash'
 import { CheckCreate, validateCheckCreate } from './checkCreate'
 import { Clawback, validateClawback } from './clawback'
-import { BaseTransaction, isIssuedCurrency } from './common'
+import {
+  BaseTransaction,
+  isIssuedCurrencyAmount,
+  validateBaseTransaction,
+} from './common'
 import { CredentialAccept, validateCredentialAccept } from './CredentialAccept'
 import { CredentialCreate, validateCredentialCreate } from './CredentialCreate'
 import { CredentialDelete, validateCredentialDelete } from './CredentialDelete'
@@ -92,6 +94,12 @@ import { SignerListSet, validateSignerListSet } from './signerListSet'
 import { TicketCreate, validateTicketCreate } from './ticketCreate'
 import { TrustSet, validateTrustSet } from './trustSet'
 import { UNLModify } from './UNLModify'
+import { VaultClawback, validateVaultClawback } from './vaultClawback'
+import { VaultCreate, validateVaultCreate } from './vaultCreate'
+import { VaultDelete, validateVaultDelete } from './vaultDelete'
+import { VaultDeposit, validateVaultDeposit } from './vaultDeposit'
+import { VaultSet, validateVaultSet } from './vaultSet'
+import { VaultWithdraw, validateVaultWithdraw } from './vaultWithdraw'
 import {
   XChainAccountCreateCommit,
   validateXChainAccountCreateCommit,
@@ -173,6 +181,12 @@ export type SubmittableTransaction =
   | SignerListSet
   | TicketCreate
   | TrustSet
+  | VaultClawback
+  | VaultCreate
+  | VaultDelete
+  | VaultDeposit
+  | VaultSet
+  | VaultWithdraw
   | XChainAccountCreateCommit
   | XChainAddAccountCreateAttestation
   | XChainAddClaimAttestation
@@ -216,50 +230,15 @@ export interface TransactionAndMetadata<
  */
 export function validate(transaction: Record<string, unknown>): void {
   const tx = { ...transaction }
-  if (tx.TransactionType == null) {
-    throw new ValidationError('Object does not have a `TransactionType`')
-  }
-  if (typeof tx.TransactionType !== 'string') {
-    throw new ValidationError("Object's `TransactionType` is not a string")
-  }
-
-  /*
-   * - Memos have exclusively hex data.
-   */
-  if (tx.Memos != null && typeof tx.Memos !== 'object') {
-    throw new ValidationError('Memo must be array')
-  }
-  if (tx.Memos != null) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- needed here
-    ;(tx.Memos as Array<Memo | null>).forEach((memo) => {
-      if (memo?.Memo == null) {
-        throw new ValidationError('Memo data must be in a `Memo` field')
-      }
-      if (memo.Memo.MemoData) {
-        if (!isHex(memo.Memo.MemoData)) {
-          throw new ValidationError('MemoData field must be a hex value')
-        }
-      }
-
-      if (memo.Memo.MemoType) {
-        if (!isHex(memo.Memo.MemoType)) {
-          throw new ValidationError('MemoType field must be a hex value')
-        }
-      }
 
-      if (memo.Memo.MemoFormat) {
-        if (!isHex(memo.Memo.MemoFormat)) {
-          throw new ValidationError('MemoFormat field must be a hex value')
-        }
-      }
-    })
-  }
+  // should already be done in the tx-specific validation, but doesn't hurt to check again
+  validateBaseTransaction(tx)
 
   Object.keys(tx).forEach((key) => {
     const standard_currency_code_len = 3
-    if (tx[key] && isIssuedCurrency(tx[key])) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- needed
-      const txCurrency = (tx[key] as IssuedCurrencyAmount).currency
+    const value = tx[key]
+    if (value && isIssuedCurrencyAmount(value)) {
+      const txCurrency = value.currency
 
       if (
         txCurrency.length === standard_currency_code_len &&
@@ -476,6 +455,30 @@ export function validate(transaction: Record<string, unknown>): void {
       validateTrustSet(tx)
       break
 
+    case 'VaultClawback':
+      validateVaultClawback(tx)
+      break
+
+    case 'VaultCreate':
+      validateVaultCreate(tx)
+      break
+
+    case 'VaultDelete':
+      validateVaultDelete(tx)
+      break
+
+    case 'VaultDeposit':
+      validateVaultDeposit(tx)
+      break
+
+    case 'VaultSet':
+      validateVaultSet(tx)
+      break
+
+    case 'VaultWithdraw':
+      validateVaultWithdraw(tx)
+      break
+
     case 'XChainAccountCreateCommit':
       validateXChainAccountCreateCommit(tx)
       break

package/src/models/transactions/vaultClawback.ts

@@ -0,0 +1,55 @@
+import { ClawbackAmount } from '../common'
+
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  validateRequiredField,
+  isString,
+  Account,
+  isAccount,
+  validateOptionalField,
+  isClawbackAmount,
+} from './common'
+
+/**
+ * The VaultClawback transaction performs a Clawback from the Vault, exchanging the shares of an account.
+ *
+ * Conceptually, the transaction performs VaultWithdraw on behalf of the Holder, sending the funds to the
+ * Issuer account of the asset. In case there are insufficient funds for the entire Amount the transaction
+ * will perform a partial Clawback, up to the Vault.AssetsAvailable. The Clawback transaction must respect
+ * any future fees or penalties.
+ *
+ * @category Transaction Models
+ */
+export interface VaultClawback extends BaseTransaction {
+  TransactionType: 'VaultClawback'
+
+  /**
+   * The ID of the vault from which assets are withdrawn.
+   */
+  VaultID: string
+
+  /**
+   * The account ID from which to clawback the assets.
+   */
+  Holder: Account
+
+  /**
+   * The asset amount to clawback. When Amount is 0 clawback all funds, up to the total shares the Holder owns.
+   */
+  Amount?: ClawbackAmount
+}
+
+/**
+ * Verify the form and type of a {@link VaultClawback} at runtime.
+ *
+ * @param tx - A {@link VaultClawback} Transaction.
+ * @throws When the {@link VaultClawback} is malformed.
+ */
+export function validateVaultClawback(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'VaultID', isString)
+  validateRequiredField(tx, 'Holder', isAccount)
+  validateOptionalField(tx, 'Amount', isClawbackAmount)
+}

package/src/models/transactions/vaultCreate.ts

@@ -0,0 +1,166 @@
+import { ValidationError } from '../../errors'
+import { Currency } from '../common'
+import { hasFlag, isHex } from '../utils'
+
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  GlobalFlagsInterface,
+  validateOptionalField,
+  isNumber,
+  isCurrency,
+  validateRequiredField,
+  isString,
+  VAULT_DATA_MAX_BYTE_LENGTH,
+  XRPLNumber,
+  isXRPLNumber,
+  MAX_MPT_META_BYTE_LENGTH,
+  MPT_META_WARNING_HEADER,
+  validateMPTokenMetadata,
+} from './common'
+
+/**
+ * Enum representing withdrawal strategies for a Vault.
+ */
+export enum VaultWithdrawalPolicy {
+  vaultStrategyFirstComeFirstServe = 0x0001,
+}
+
+/**
+ * Enum representing values of {@link VaultCreate} transaction flags.
+ *
+ * @category Transaction Flags
+ */
+export enum VaultCreateFlags {
+  tfVaultPrivate = 0x00010000,
+  tfVaultShareNonTransferable = 0x00020000,
+}
+
+/**
+ * Map of flags to boolean values representing {@link VaultCreate} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface VaultCreateFlagsInterface extends GlobalFlagsInterface {
+  tfVaultPrivate?: boolean
+  tfVaultShareNonTransferable?: boolean
+}
+
+/**
+ * The VaultCreate transaction creates a new Vault object.
+ *
+ * @category Transaction Models
+ */
+export interface VaultCreate extends BaseTransaction {
+  TransactionType: 'VaultCreate'
+
+  /**
+   * The asset (XRP, IOU or MPT) of the Vault.
+   */
+  Asset: Currency
+
+  /**
+   * Arbitrary Vault metadata, limited to 256 bytes.
+   */
+  Data?: string
+
+  /**
+   * The maximum asset amount that can be held in a vault.
+   */
+  AssetsMaximum?: XRPLNumber
+
+  /**
+   * Arbitrary metadata about the share MPT, in hex format, limited to 1024 bytes.
+   *
+   * The decoded value must be a UTF-8 encoded JSON object that adheres to the
+   * XLS-89d MPTokenMetadata standard.
+   *
+   * While adherence to the XLS-89d format is not mandatory, non-compliant metadata
+   * may not be discoverable by ecosystem tools such as explorers and indexers.
+   */
+  MPTokenMetadata?: string
+
+  /**
+   * Indicates the withdrawal strategy used by the Vault.
+   */
+  WithdrawalPolicy?: number
+
+  /**
+   * The PermissionedDomain object ID associated with the shares of this Vault.
+   */
+  DomainID?: string
+}
+
+/* eslint-disable max-lines-per-function -- Not needed to reduce function */
+/* eslint-disable max-statements -- required to do all field validations */
+/**
+ * Verify the form and type of an {@link VaultCreate} at runtime.
+ *
+ * @param tx - A {@link VaultCreate} Transaction.
+ * @throws When the {@link VaultCreate} is malformed.
+ */
+export function validateVaultCreate(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'Asset', isCurrency)
+  validateOptionalField(tx, 'Data', isString)
+  validateOptionalField(tx, 'AssetsMaximum', isXRPLNumber)
+  validateOptionalField(tx, 'MPTokenMetadata', isString)
+  validateOptionalField(tx, 'WithdrawalPolicy', isNumber)
+  validateOptionalField(tx, 'DomainID', isString)
+
+  if (tx.Data !== undefined) {
+    const dataHex = tx.Data
+    if (!isHex(dataHex)) {
+      throw new ValidationError('VaultCreate: Data must be a valid hex string')
+    }
+    const dataByteLength = dataHex.length / 2
+    if (dataByteLength > VAULT_DATA_MAX_BYTE_LENGTH) {
+      throw new ValidationError(
+        `VaultCreate: Data exceeds ${VAULT_DATA_MAX_BYTE_LENGTH} bytes (actual: ${dataByteLength})`,
+      )
+    }
+  }
+
+  if (tx.MPTokenMetadata !== undefined) {
+    const metaHex = tx.MPTokenMetadata
+    if (!isHex(metaHex)) {
+      throw new ValidationError(
+        'VaultCreate: MPTokenMetadata must be a valid non-empty hex string',
+      )
+    }
+    const metaByteLength = metaHex.length / 2
+    if (metaByteLength > MAX_MPT_META_BYTE_LENGTH) {
+      throw new ValidationError(
+        `VaultCreate: MPTokenMetadata exceeds ${MAX_MPT_META_BYTE_LENGTH} bytes (actual: ${metaByteLength})`,
+      )
+    }
+  }
+
+  // If DomainID present, tfVaultPrivate must be set
+  if (
+    tx.DomainID !== undefined &&
+    !hasFlag(tx, VaultCreateFlags.tfVaultPrivate, 'tfVaultPrivate')
+  ) {
+    throw new ValidationError(
+      'VaultCreate: Cannot set DomainID unless tfVaultPrivate flag is set.',
+    )
+  }
+
+  if (tx.MPTokenMetadata != null) {
+    const validationMessages = validateMPTokenMetadata(tx.MPTokenMetadata)
+
+    if (validationMessages.length > 0) {
+      const message = [
+        MPT_META_WARNING_HEADER,
+        ...validationMessages.map((msg) => `- ${msg}`),
+      ].join('\n')
+
+      // eslint-disable-next-line no-console -- Required here.
+      console.warn(message)
+    }
+  }
+}
+/* eslint-enable max-lines-per-function */
+/* eslint-enable max-statements */

package/src/models/transactions/vaultDelete.ts

@@ -0,0 +1,32 @@
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  validateRequiredField,
+  isString,
+} from './common'
+
+/**
+ * The VaultDelete transaction deletes an existing vault object.
+ *
+ * @category Transaction Models
+ */
+export interface VaultDelete extends BaseTransaction {
+  TransactionType: 'VaultDelete'
+
+  /**
+   * The ID of the vault to be deleted.
+   */
+  VaultID: string
+}
+
+/**
+ * Verify the form and type of a {@link VaultDelete} at runtime.
+ *
+ * @param tx - A {@link VaultDelete} Transaction.
+ * @throws When the {@link VaultDelete} is malformed.
+ */
+export function validateVaultDelete(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'VaultID', isString)
+}