xrpl 4.3.0-smartescrow.3 → 4.4.0-smartescrow.0

package/src/models/transactions/oracleSet.ts

@@ -4,7 +4,9 @@ import { isHex } from '../utils'
 
 import {
   BaseTransaction,
+  isArray,
   isNumber,
+  isRecord,
   isString,
   validateBaseTransaction,
   validateOptionalField,
@@ -86,113 +88,108 @@ export function validateOracleSet(tx: Record<string, unknown>): void {
   validateOptionalField(tx, 'AssetClass', isString)
 
   /* eslint-disable max-statements, max-lines-per-function -- necessary to validate many fields */
-  validateRequiredField(tx, 'PriceDataSeries', (value) => {
-    if (!Array.isArray(value)) {
-      throw new ValidationError('OracleSet: PriceDataSeries must be an array')
-    }
-
-    if (value.length > PRICE_DATA_SERIES_MAX_LENGTH) {
-      throw new ValidationError(
-        `OracleSet: PriceDataSeries must have at most ${PRICE_DATA_SERIES_MAX_LENGTH} PriceData objects`,
-      )
-    }
-
-    // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
-    for (const priceData of value) {
-      if (typeof priceData !== 'object') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must be an array of objects',
-        )
+  validateRequiredField(
+    tx,
+    'PriceDataSeries',
+    (value: unknown): value is PriceData => {
+      if (!isArray(value)) {
+        throw new ValidationError('OracleSet: PriceDataSeries must be an array')
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-      if (priceData.PriceData == null) {
+      if (value.length > PRICE_DATA_SERIES_MAX_LENGTH) {
         throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `PriceData` object',
+          `OracleSet: PriceDataSeries must have at most ${PRICE_DATA_SERIES_MAX_LENGTH} PriceData objects`,
         )
       }
 
-      // check if priceData only has PriceData
-      if (Object.keys(priceData).length !== 1) {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must only have a single PriceData object',
-        )
-      }
+      // TODO: add support for handling inner objects easier (similar to validateRequiredField/validateOptionalField)
+      for (const priceData of value) {
+        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 (typeof priceData.PriceData.BaseAsset !== 'string') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `BaseAsset` string',
-        )
-      }
+        const priceDataInner = priceData.PriceData
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- we are validating the type
-      if (typeof priceData.PriceData.QuoteAsset !== 'string') {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
-        )
-      }
+        if (!isRecord(priceDataInner)) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `PriceData` object',
+          )
+        }
 
-      // 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)
-      ) {
-        throw new ValidationError(
-          'OracleSet: PriceDataSeries must have both `AssetPrice` and `Scale` if any are present',
-        )
-      }
+        // check if priceData only has PriceData
+        if (Object.keys(priceData).length !== 1) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must only have a single PriceData object',
+          )
+        }
 
-      /* 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') {
-            throw new ValidationError(
-              'OracleSet: Field AssetPrice must be a string or a number',
-            )
+        if (
+          priceDataInner.BaseAsset == null ||
+          typeof priceDataInner.BaseAsset !== 'string'
+        ) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `BaseAsset` string',
+          )
+        }
+
+        if (typeof priceDataInner.QuoteAsset !== 'string') {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have a `QuoteAsset` string',
+          )
+        }
+
+        // Either AssetPrice and Scale are both present or both excluded
+        if (
+          (priceDataInner.AssetPrice == null) !==
+          (priceDataInner.Scale == null)
+        ) {
+          throw new ValidationError(
+            'OracleSet: PriceDataSeries must have both `AssetPrice` and `Scale` if any are present',
+          )
+        }
+
+        /* 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(priceDataInner.AssetPrice)) {
+              throw new ValidationError(
+                'OracleSet: Field AssetPrice must be a valid hex string',
+              )
+            }
+            if (
+              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`,
+              )
+            }
           }
-          if (!isHex(priceData.PriceData.AssetPrice)) {
-            throw new ValidationError(
-              'OracleSet: Field AssetPrice must be a valid hex string',
-            )
+        }
+
+        if ('Scale' in priceDataInner) {
+          if (!isNumber(priceDataInner.Scale)) {
+            throw new ValidationError('OracleSet: invalid field Scale')
           }
-          if (
-            priceData.PriceData.AssetPrice.length <
-              MINIMUM_ASSET_PRICE_LENGTH ||
-            priceData.PriceData.AssetPrice.length > MAXIMUM_ASSET_PRICE_LENGTH
-          ) {
+
+          if (priceDataInner.Scale < 0 || priceDataInner.Scale > SCALE_MAX) {
             throw new ValidationError(
-              `OracleSet: Length of AssetPrice field must be between ${MINIMUM_ASSET_PRICE_LENGTH} and ${MAXIMUM_ASSET_PRICE_LENGTH} characters long`,
+              `OracleSet: Scale must be in range 0-${SCALE_MAX}`,
             )
           }
+          /* eslint-enable max-depth */
         }
       }
-      /* 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 (
-        // 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}`,
-        )
-      }
-    }
-    return true
-  })
+      return true
+    },
+  )
   /* eslint-enable max-statements, max-lines-per-function */
 }

package/src/models/transactions/payment.ts

@@ -5,7 +5,7 @@ import { isFlagEnabled } from '../utils'
 import {
   BaseTransaction,
   isAmount,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   isAccount,
   validateRequiredField,
@@ -14,6 +14,7 @@ import {
   Account,
   validateCredentialsList,
   MAX_AUTHORIZED_CREDENTIALS,
+  isArray,
 } from './common'
 import type { TransactionMetadataBase } from './metadata'
 
@@ -84,7 +85,7 @@ export enum PaymentFlags {
  * // }
  * ```
  */
-export interface PaymentFlagsInterface extends GlobalFlags {
+export interface PaymentFlagsInterface extends GlobalFlagsInterface {
   /**
    * Do not use the default path; only use paths included in the Paths field.
    * This is intended to force the transaction to take arbitrage opportunities.
@@ -119,6 +120,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
   /**
@@ -186,8 +190,7 @@ export function validatePayment(tx: Record<string, unknown>): void {
 
   validateCredentialsList(
     tx.CredentialIDs,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     true,
     MAX_AUTHORIZED_CREDENTIALS,
   )
@@ -196,11 +199,7 @@ 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>>>)
-  ) {
+  if (tx.Paths !== undefined && !isPaths(tx.Paths)) {
     throw new ValidationError('PaymentTransaction: invalid Paths')
   }
 
@@ -209,6 +208,12 @@ export function validatePayment(tx: Record<string, unknown>): void {
   }
 
   checkPartialPayment(tx)
+
+  if (tx.DeliverMax != null) {
+    throw new ValidationError(
+      'PaymentTransaction: Cannot have DeliverMax in a submitted transaction',
+    )
+  }
 }
 
 function checkPartialPayment(tx: Record<string, unknown>): void {
@@ -264,7 +269,10 @@ function isPathStep(pathStep: Record<string, unknown>): boolean {
   return false
 }
 
-function isPath(path: Array<Record<string, unknown>>): boolean {
+function isPath(path: unknown): path is Path {
+  if (!Array.isArray(path) || path.length === 0) {
+    return false
+  }
   for (const pathStep of path) {
     if (!isPathStep(pathStep)) {
       return false
@@ -273,13 +281,13 @@ function isPath(path: Array<Record<string, unknown>>): boolean {
   return true
 }
 
-function isPaths(paths: Array<Array<Record<string, unknown>>>): boolean {
-  if (!Array.isArray(paths) || paths.length === 0) {
+function isPaths(paths: unknown): paths is Path[] {
+  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/paymentChannelClaim.ts

@@ -2,7 +2,7 @@ import { ValidationError } from '../../errors'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   validateCredentialsList,
   MAX_AUTHORIZED_CREDENTIALS,
@@ -73,7 +73,8 @@ export enum PaymentChannelClaimFlags {
  * // }
  * ```
  */
-export interface PaymentChannelClaimFlagsInterface extends GlobalFlags {
+export interface PaymentChannelClaimFlagsInterface
+  extends GlobalFlagsInterface {
   /**
    * Clear the channel's Expiration time. (Expiration is different from the
    * channel's immutable CancelAfter time.) Only the source address of the
@@ -151,8 +152,7 @@ export function validatePaymentChannelClaim(tx: Record<string, unknown>): void {
 
   validateCredentialsList(
     tx.CredentialIDs,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     true,
     MAX_AUTHORIZED_CREDENTIALS,
   )

package/src/models/transactions/permissionedDomainSet.ts

@@ -7,6 +7,7 @@ import {
   validateOptionalField,
   validateRequiredField,
   validateCredentialsList,
+  isArray,
 } from './common'
 
 const MAX_ACCEPTED_CREDENTIALS = 10
@@ -36,16 +37,11 @@ export function validatePermissionedDomainSet(
   validateBaseTransaction(tx)
 
   validateOptionalField(tx, 'DomainID', isString)
-  validateRequiredField(
-    tx,
-    'AcceptedCredentials',
-    () => tx.AcceptedCredentials instanceof Array,
-  )
+  validateRequiredField(tx, 'AcceptedCredentials', isArray)
 
   validateCredentialsList(
     tx.AcceptedCredentials,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
-    tx.TransactionType as string,
+    tx.TransactionType,
     // PermissionedDomainSet uses AuthorizeCredential nested objects only, strings are not allowed
     false,
     // PermissionedDomainSet uses at most 10 accepted credentials. This is different from Credential-feature transactions.

package/src/models/transactions/signerListSet.ts

@@ -1,7 +1,15 @@
 import { ValidationError } from '../../errors'
 import { SignerEntry } from '../common'
 
-import { BaseTransaction, 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 (!Array.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'
@@ -15,11 +13,16 @@ import { AMMDelete, validateAMMDelete } from './AMMDelete'
 import { AMMDeposit, validateAMMDeposit } from './AMMDeposit'
 import { AMMVote, validateAMMVote } from './AMMVote'
 import { AMMWithdraw, validateAMMWithdraw } from './AMMWithdraw'
+import { Batch, validateBatch } from './batch'
 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'
@@ -91,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,
@@ -133,6 +142,7 @@ export type SubmittableTransaction =
   | AMMWithdraw
   | AccountDelete
   | AccountSet
+  | Batch
   | CheckCancel
   | CheckCash
   | CheckCreate
@@ -171,6 +181,12 @@ export type SubmittableTransaction =
   | SignerListSet
   | TicketCreate
   | TrustSet
+  | VaultClawback
+  | VaultCreate
+  | VaultDelete
+  | VaultDeposit
+  | VaultSet
+  | VaultWithdraw
   | XChainAccountCreateCommit
   | XChainAddAccountCreateAttestation
   | XChainAddClaimAttestation
@@ -214,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 &&
@@ -309,6 +290,19 @@ export function validate(transaction: Record<string, unknown>): void {
       validateAccountSet(tx)
       break
 
+    case 'Batch':
+      validateBatch(tx)
+      // This is done here to avoid issues with dependency cycles
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- okay here
+      // @ts-expect-error -- already checked
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call -- already checked above
+      tx.RawTransactions.forEach((innerTx: Record<string, unknown>) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- already checked above
+        validate(innerTx.RawTransaction as Record<string, unknown>)
+      })
+      break
+
     case 'CheckCancel':
       validateCheckCancel(tx)
       break
@@ -461,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/trustSet.ts

@@ -3,7 +3,7 @@ import { IssuedCurrencyAmount } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   validateBaseTransaction,
 } from './common'
@@ -77,7 +77,7 @@ export enum TrustSetFlags {
  * // }
  * ```
  */
-export interface TrustSetFlagsInterface extends GlobalFlags {
+export interface TrustSetFlagsInterface extends GlobalFlagsInterface {
   /**
    * Authorize the other party to hold currency issued by this account. (No
    * effect unless using the asfRequireAuth AccountSet flag.) Cannot be unset.

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)
+}