refactor: clean up transaction model validations

.vscode/settings.json

@@ -12,12 +12,14 @@
         "multisign",
         "multisigned",
         "multisigning",
-        "Permissioned",
+        "nftoken",
+        "permissioned",
         "preauthorization",
         "rippletest",
         "secp256k1",
         "Setf",
         "Sidechains",
+        "Trustlines",
         "xchain",
         "xrplf"
     ],

packages/ripple-binary-codec/src/types/st-array.ts

@@ -17,6 +17,7 @@ function isObjects(args): args is Array<JsonObject> {
     Array.isArray(args) &&
     args.every(
       (arg) =>
+        arg != null &&
         typeof arg === 'object' &&
         Object.keys(arg).length === 1 &&
         typeof Object.values(arg)[0] === 'object',

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

@@ -20,6 +20,8 @@ export interface MPTCurrency {
 
 export type Currency = IssuedCurrency | MPTCurrency | XRP
 
+export type XRPAmount = string
+
 export interface IssuedCurrencyAmount extends IssuedCurrency {
   value: string
 }
@@ -29,7 +31,7 @@ export interface MPTAmount {
   value: string
 }
 
-export type Amount = IssuedCurrencyAmount | string
+export type Amount = IssuedCurrencyAmount | XRPAmount
 
 export type ClawbackAmount = IssuedCurrencyAmount | MPTAmount
 

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

@@ -2,12 +2,16 @@ import { ValidationError } from '../../errors'
 import { AuthAccount, Currency, IssuedCurrencyAmount } from '../common'
 
 import {
+  Account,
   BaseTransaction,
+  isAccount,
   isAmount,
   isArray,
-  isIssuedCurrency,
+  isCurrency,
   isRecord,
   validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
 } from './common'
 
 const MAX_AUTH_ACCOUNTS = 4
@@ -63,29 +67,10 @@ export interface AMMBid extends BaseTransaction {
 export function validateAMMBid(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.Asset == null) {
-    throw new ValidationError('AMMBid: missing field Asset')
-  }
-
-  if (!isIssuedCurrency(tx.Asset)) {
-    throw new ValidationError('AMMBid: Asset must be a Currency')
-  }
-
-  if (tx.Asset2 == null) {
-    throw new ValidationError('AMMBid: missing field Asset2')
-  }
-
-  if (!isIssuedCurrency(tx.Asset2)) {
-    throw new ValidationError('AMMBid: Asset2 must be a Currency')
-  }
-
-  if (tx.BidMin != null && !isAmount(tx.BidMin)) {
-    throw new ValidationError('AMMBid: BidMin must be an Amount')
-  }
-
-  if (tx.BidMax != null && !isAmount(tx.BidMax)) {
-    throw new ValidationError('AMMBid: BidMax must be an Amount')
-  }
+  validateRequiredField(tx, 'Asset', isCurrency)
+  validateRequiredField(tx, 'Asset2', isCurrency)
+  validateOptionalField(tx, 'BidMin', isAmount)
+  validateOptionalField(tx, 'BidMax', isAmount)
 
   if (tx.AuthAccounts != null) {
     if (!isArray(tx.AuthAccounts)) {
@@ -103,28 +88,32 @@ export function validateAMMBid(tx: Record<string, unknown>): void {
 }
 
 function validateAuthAccounts(
-  senderAddress: string,
+  senderAddress: Account,
   authAccounts: unknown[],
 ): boolean {
-  for (const authAccount of authAccounts) {
+  authAccounts.forEach((authAccount, index) => {
     if (!isRecord(authAccount)) {
-      throw new ValidationError(`AMMBid: invalid AuthAccounts`)
+      throw new ValidationError(
+        `AMMBid: invalid field AuthAccounts[0], expected a valid Record`,
+      )
     }
+    const paramName = `AuthAccounts[${index}].AuthAccount`
     if (!isRecord(authAccount.AuthAccount)) {
-      throw new ValidationError(`AMMBid: invalid AuthAccounts`)
-    }
-    if (authAccount.AuthAccount.Account == null) {
-      throw new ValidationError(`AMMBid: invalid AuthAccounts`)
-    }
-    if (typeof authAccount.AuthAccount.Account !== 'string') {
-      throw new ValidationError(`AMMBid: invalid AuthAccounts`)
+      throw new ValidationError(
+        `AMMBid: invalid field ${paramName}, expected a valid Record`,
+      )
     }
+    const authAccountInner = authAccount.AuthAccount
+    validateRequiredField(authAccountInner, 'Account', isAccount, {
+      paramName,
+      txType: 'AMMBid',
+    })
     if (authAccount.AuthAccount.Account === senderAddress) {
       throw new ValidationError(
         `AMMBid: AuthAccounts must not include sender's address`,
       )
     }
-  }
+  })
 
   return true
 }

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

@@ -6,6 +6,7 @@ import {
   BaseTransaction,
   GlobalFlagsInterface,
   isAccount,
+  isCurrency,
   isIssuedCurrency,
   isIssuedCurrencyAmount,
   validateBaseTransaction,
@@ -97,7 +98,7 @@ export function validateAMMClawback(tx: Record<string, unknown>): void {
     )
   }
 
-  validateRequiredField(tx, 'Asset2', isIssuedCurrency)
+  validateRequiredField(tx, 'Asset2', isCurrency)
 
   validateOptionalField(tx, 'Amount', isIssuedCurrencyAmount)
 

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

@@ -1,7 +1,12 @@
-import { ValidationError } from '../../errors'
 import { Amount } from '../common'
 
-import { BaseTransaction, isAmount, validateBaseTransaction } from './common'
+import {
+  BaseTransaction,
+  isAmount,
+  isNumberWithBounds,
+  validateBaseTransaction,
+  validateRequiredField,
+} from './common'
 
 export const AMM_MAX_TRADING_FEE = 1000
 
@@ -48,33 +53,11 @@ export interface AMMCreate extends BaseTransaction {
 export function validateAMMCreate(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.Amount == null) {
-    throw new ValidationError('AMMCreate: missing field Amount')
-  }
-
-  if (!isAmount(tx.Amount)) {
-    throw new ValidationError('AMMCreate: Amount must be an Amount')
-  }
-
-  if (tx.Amount2 == null) {
-    throw new ValidationError('AMMCreate: missing field Amount2')
-  }
-
-  if (!isAmount(tx.Amount2)) {
-    throw new ValidationError('AMMCreate: Amount2 must be an Amount')
-  }
-
-  if (tx.TradingFee == null) {
-    throw new ValidationError('AMMCreate: missing field TradingFee')
-  }
-
-  if (typeof tx.TradingFee !== 'number') {
-    throw new ValidationError('AMMCreate: TradingFee must be a number')
-  }
-
-  if (tx.TradingFee < 0 || tx.TradingFee > AMM_MAX_TRADING_FEE) {
-    throw new ValidationError(
-      `AMMCreate: TradingFee must be between 0 and ${AMM_MAX_TRADING_FEE}`,
-    )
-  }
+  validateRequiredField(tx, 'Amount', isAmount)
+  validateRequiredField(tx, 'Amount2', isAmount)
+  validateRequiredField(
+    tx,
+    'TradingFee',
+    isNumberWithBounds(0, AMM_MAX_TRADING_FEE),
+  )
 }

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

@@ -1,10 +1,10 @@
-import { ValidationError } from '../../errors'
 import { Currency } from '../common'
 
 import {
   BaseTransaction,
-  isIssuedCurrency,
+  isCurrency,
   validateBaseTransaction,
+  validateRequiredField,
 } from './common'
 
 /**
@@ -41,19 +41,6 @@ export interface AMMDelete extends BaseTransaction {
 export function validateAMMDelete(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.Asset == null) {
-    throw new ValidationError('AMMDelete: missing field Asset')
-  }
-
-  if (!isIssuedCurrency(tx.Asset)) {
-    throw new ValidationError('AMMDelete: Asset must be a Currency')
-  }
-
-  if (tx.Asset2 == null) {
-    throw new ValidationError('AMMDelete: missing field Asset2')
-  }
-
-  if (!isIssuedCurrency(tx.Asset2)) {
-    throw new ValidationError('AMMDelete: Asset2 must be a Currency')
-  }
+  validateRequiredField(tx, 'Asset', isCurrency)
+  validateRequiredField(tx, 'Asset2', isCurrency)
 }

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

@@ -5,9 +5,11 @@ import {
   BaseTransaction,
   GlobalFlagsInterface,
   isAmount,
-  isIssuedCurrency,
+  isCurrency,
   isIssuedCurrencyAmount,
   validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
 } from './common'
 
 /**
@@ -85,21 +87,12 @@ export interface AMMDeposit extends BaseTransaction {
 export function validateAMMDeposit(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.Asset == null) {
-    throw new ValidationError('AMMDeposit: missing field Asset')
-  }
-
-  if (!isIssuedCurrency(tx.Asset)) {
-    throw new ValidationError('AMMDeposit: Asset must be a Currency')
-  }
-
-  if (tx.Asset2 == null) {
-    throw new ValidationError('AMMDeposit: missing field Asset2')
-  }
-
-  if (!isIssuedCurrency(tx.Asset2)) {
-    throw new ValidationError('AMMDeposit: Asset2 must be a Currency')
-  }
+  validateRequiredField(tx, 'Asset', isCurrency)
+  validateRequiredField(tx, 'Asset2', isCurrency)
+  validateOptionalField(tx, 'LPTokenOut', isIssuedCurrencyAmount)
+  validateOptionalField(tx, 'Amount', isAmount)
+  validateOptionalField(tx, 'Amount2', isAmount)
+  validateOptionalField(tx, 'EPrice', isAmount)
 
   if (tx.Amount2 != null && tx.Amount == null) {
     throw new ValidationError('AMMDeposit: must set Amount with Amount2')
@@ -110,22 +103,4 @@ export function validateAMMDeposit(tx: Record<string, unknown>): void {
       'AMMDeposit: must set at least LPTokenOut or Amount',
     )
   }
-
-  if (tx.LPTokenOut != null && !isIssuedCurrencyAmount(tx.LPTokenOut)) {
-    throw new ValidationError(
-      'AMMDeposit: LPTokenOut must be an IssuedCurrencyAmount',
-    )
-  }
-
-  if (tx.Amount != null && !isAmount(tx.Amount)) {
-    throw new ValidationError('AMMDeposit: Amount must be an Amount')
-  }
-
-  if (tx.Amount2 != null && !isAmount(tx.Amount2)) {
-    throw new ValidationError('AMMDeposit: Amount2 must be an Amount')
-  }
-
-  if (tx.EPrice != null && !isAmount(tx.EPrice)) {
-    throw new ValidationError('AMMDeposit: EPrice must be an Amount')
-  }
 }

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

@@ -1,11 +1,13 @@
-import { ValidationError } from '../../errors'
 import { Currency } from '../common'
 
 import { AMM_MAX_TRADING_FEE } from './AMMCreate'
 import {
   BaseTransaction,
-  isIssuedCurrency,
+  isCurrency,
+  isNumber,
+  isNumberWithBounds,
   validateBaseTransaction,
+  validateRequiredField,
 } from './common'
 
 /**
@@ -43,33 +45,12 @@ export interface AMMVote extends BaseTransaction {
 export function validateAMMVote(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.Asset == null) {
-    throw new ValidationError('AMMVote: missing field Asset')
-  }
-
-  if (!isIssuedCurrency(tx.Asset)) {
-    throw new ValidationError('AMMVote: Asset must be a Currency')
-  }
-
-  if (tx.Asset2 == null) {
-    throw new ValidationError('AMMVote: missing field Asset2')
-  }
-
-  if (!isIssuedCurrency(tx.Asset2)) {
-    throw new ValidationError('AMMVote: Asset2 must be a Currency')
-  }
-
-  if (tx.TradingFee == null) {
-    throw new ValidationError('AMMVote: missing field TradingFee')
-  }
-
-  if (typeof tx.TradingFee !== 'number') {
-    throw new ValidationError('AMMVote: TradingFee must be a number')
-  }
-
-  if (tx.TradingFee < 0 || tx.TradingFee > AMM_MAX_TRADING_FEE) {
-    throw new ValidationError(
-      `AMMVote: TradingFee must be between 0 and ${AMM_MAX_TRADING_FEE}`,
-    )
-  }
+  validateRequiredField(tx, 'Asset', isCurrency)
+  validateRequiredField(tx, 'Asset2', isCurrency)
+  validateRequiredField(tx, 'TradingFee', isNumber)
+  validateRequiredField(
+    tx,
+    'TradingFee',
+    isNumberWithBounds(0, AMM_MAX_TRADING_FEE),
+  )
 }