xrpl 4.0.1-mpt-beta → 4.2.0-batch.0

package/src/models/transactions/CredentialAccept.ts

@@ -0,0 +1,44 @@
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateCredentialType,
+  validateRequiredField,
+} from './common'
+
+/**
+ * Accepts a credential issued to the Account (i.e. the Account is the Subject of the Credential object).
+ * Credentials are represented in hex. Whilst they are allowed a maximum length of 64
+ * bytes, every byte requires 2 hex characters for representation.
+ * The credential is not considered valid until it has been transferred/accepted.
+ *
+ * @category Transaction Models
+ * */
+export interface CredentialAccept extends BaseTransaction {
+  TransactionType: 'CredentialAccept'
+
+  /** The subject of the credential. */
+  Account: string
+
+  /** The issuer of the credential. */
+  Issuer: string
+
+  /** A hex-encoded value to identify the type of credential from the issuer. */
+  CredentialType: string
+}
+
+/**
+ * Verify the form and type of a CredentialAccept at runtime.
+ *
+ * @param tx - A CredentialAccept Transaction.
+ * @throws When the CredentialAccept is Malformed.
+ */
+export function validateCredentialAccept(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'Account', isString)
+
+  validateRequiredField(tx, 'Issuer', isString)
+
+  validateCredentialType(tx)
+}

package/src/models/transactions/CredentialCreate.ts

@@ -0,0 +1,81 @@
+import { HEX_REGEX } from '@xrplf/isomorphic/utils'
+
+import { ValidationError } from '../../errors'
+
+import {
+  BaseTransaction,
+  isNumber,
+  isString,
+  validateBaseTransaction,
+  validateCredentialType,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+const MAX_URI_LENGTH = 256
+
+/**
+ * Creates a Credential object. It must be sent by the issuer.
+ *
+ * @category Transaction Models
+ * */
+export interface CredentialCreate extends BaseTransaction {
+  TransactionType: 'CredentialCreate'
+
+  /** The issuer of the credential. */
+  Account: string
+
+  /** The subject of the credential. */
+  Subject: string
+
+  /** A hex-encoded value to identify the type of credential from the issuer. */
+  CredentialType: string
+
+  /** Credential expiration. */
+  Expiration?: number
+
+  /** Additional data about the credential (such as a link to the VC document). */
+  URI?: string
+}
+
+/**
+ * Verify the form and type of a CredentialCreate at runtime.
+ *
+ * @param tx - A CredentialCreate Transaction.
+ * @throws When the CredentialCreate is Malformed.
+ */
+export function validateCredentialCreate(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'Account', isString)
+
+  validateRequiredField(tx, 'Subject', isString)
+
+  validateCredentialType(tx)
+
+  validateOptionalField(tx, 'Expiration', isNumber)
+
+  validateURI(tx.URI)
+}
+
+function validateURI(URI: unknown): void {
+  if (URI === undefined) {
+    return
+  }
+
+  if (typeof URI !== 'string') {
+    throw new ValidationError('CredentialCreate: invalid field URI')
+  }
+
+  if (URI.length === 0) {
+    throw new ValidationError('CredentialCreate: URI cannot be an empty string')
+  } else if (URI.length > MAX_URI_LENGTH) {
+    throw new ValidationError(
+      `CredentialCreate: URI length must be <= ${MAX_URI_LENGTH}`,
+    )
+  }
+
+  if (!HEX_REGEX.test(URI)) {
+    throw new ValidationError('CredentialCreate: URI must be encoded in hex')
+  }
+}

package/src/models/transactions/CredentialDelete.ts

@@ -0,0 +1,55 @@
+import { ValidationError } from '../../errors'
+
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateCredentialType,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+/**
+ * Deletes a Credential object.
+ *
+ * @category Transaction Models
+ * */
+export interface CredentialDelete extends BaseTransaction {
+  TransactionType: 'CredentialDelete'
+
+  /** The transaction submitter. */
+  Account: string
+
+  /** A hex-encoded value to identify the type of credential from the issuer. */
+  CredentialType: string
+
+  /** The person that the credential is for. If omitted, Account is assumed to be the subject. */
+  Subject?: string
+
+  /** The issuer of the credential. If omitted, Account is assumed to be the issuer. */
+  Issuer?: string
+}
+
+/**
+ * Verify the form and type of a CredentialDelete at runtime.
+ *
+ * @param tx - A CredentialDelete Transaction.
+ * @throws When the CredentialDelete is Malformed.
+ */
+export function validateCredentialDelete(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (!tx.Subject && !tx.Issuer) {
+    throw new ValidationError(
+      'CredentialDelete: either `Issuer` or `Subject` must be provided',
+    )
+  }
+
+  validateRequiredField(tx, 'Account', isString)
+
+  validateCredentialType(tx)
+
+  validateOptionalField(tx, 'Subject', isString)
+
+  validateOptionalField(tx, 'Issuer', isString)
+}

package/src/models/transactions/MPTokenAuthorize.ts

@@ -6,7 +6,7 @@ import {
   Account,
   validateOptionalField,
   isAccount,
-  GlobalFlags,
+  GlobalFlagsInterface,
 } from './common'
 
 /**
@@ -32,7 +32,7 @@ export enum MPTokenAuthorizeFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenAuthorizeFlagsInterface extends GlobalFlags {
+export interface MPTokenAuthorizeFlagsInterface extends GlobalFlagsInterface {
   tfMPTUnauthorize?: boolean
 }
 
@@ -50,7 +50,7 @@ export interface MPTokenAuthorize extends BaseTransaction {
    * An optional XRPL Address of an individual token holder balance to lock/unlock.
    * If omitted, this transaction will apply to all any accounts holding MPTs.
    */
-  MPTokenHolder?: Account
+  Holder?: Account
   Flags?: number | MPTokenAuthorizeFlagsInterface
 }
 
@@ -63,5 +63,5 @@ export interface MPTokenAuthorize extends BaseTransaction {
 export function validateMPTokenAuthorize(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
   validateRequiredField(tx, 'MPTokenIssuanceID', isString)
-  validateOptionalField(tx, 'MPTokenHolder', isAccount)
+  validateOptionalField(tx, 'Holder', isAccount)
 }

package/src/models/transactions/MPTokenIssuanceCreate.ts

@@ -1,9 +1,20 @@
 import { ValidationError } from '../../errors'
-import { isHex } from '../utils'
+import { isHex, INTEGER_SANITY_CHECK, isFlagEnabled } from '../utils'
 
-import { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'
+import {
+  BaseTransaction,
+  GlobalFlagsInterface,
+  validateBaseTransaction,
+  validateOptionalField,
+  isString,
+  isNumber,
+} from './common'
 import type { TransactionMetadataBase } from './metadata'
 
+// 2^63 - 1
+const MAX_AMT = '9223372036854775807'
+const MAX_TRANSFER_FEE = 50000
+
 /**
  * Transaction Flags for an MPTokenIssuanceCreate Transaction.
  *
@@ -25,7 +36,7 @@ export enum MPTokenIssuanceCreateFlags {
    */
   tfMPTCanEscrow = 0x00000008,
   /**
-   * 	If set, indicates that individual holders can trade their balances
+   * If set, indicates that individual holders can trade their balances
    *  using the XRP Ledger DEX or AMM.
    */
   tfMPTCanTrade = 0x00000010,
@@ -47,7 +58,8 @@ export enum MPTokenIssuanceCreateFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenIssuanceCreateFlagsInterface extends GlobalFlags {
+export interface MPTokenIssuanceCreateFlagsInterface
+  extends GlobalFlagsInterface {
   tfMPTCanLock?: boolean
   tfMPTRequireAuth?: boolean
   tfMPTCanEscrow?: boolean
@@ -75,17 +87,13 @@ export interface MPTokenIssuanceCreate extends BaseTransaction {
    */
   AssetScale?: number
   /**
-   * Specifies the hex-encoded maximum asset amount of this token that should ever be issued.
-   * It is a non-negative integer that can store a range of up to 63 bits. If not set, the max
-   * amount will default to the largest unsigned 63-bit integer (0x7FFFFFFFFFFFFFFF)
-   *
-   * Helper function `mptUint64ToHex` can be used to help converting from base 10 or 16 string
-   * to a valid value.
+   * Specifies the maximum asset amount of this token that should ever be issued.
+   * It is a non-negative integer string that can store a range of up to 63 bits. If not set, the max
+   * amount will default to the largest unsigned 63-bit integer (0x7FFFFFFFFFFFFFFF or 9223372036854775807)
    *
    * Example:
    * ```
-   * MaximumAmount: '3e8' // 0x3E8 in hex or 1000 in decimal
-   * MaximumAmount:  mptUint64ToHex('1000') // 1000 in decimal using helper function
+   * MaximumAmount: '9223372036854775807'
    * ```
    */
   MaximumAmount?: string
@@ -107,6 +115,7 @@ export interface MPTokenIssuanceCreateMetadata extends TransactionMetadataBase {
   mpt_issuance_id?: string
 }
 
+/* eslint-disable max-lines-per-function -- Not needed to reduce function */
 /**
  * Verify the form and type of an MPTokenIssuanceCreate at runtime.
  *
@@ -117,6 +126,10 @@ export function validateMPTokenIssuanceCreate(
   tx: Record<string, unknown>,
 ): void {
   validateBaseTransaction(tx)
+  validateOptionalField(tx, 'MaximumAmount', isString)
+  validateOptionalField(tx, 'MPTokenMetadata', isString)
+  validateOptionalField(tx, 'TransferFee', isNumber)
+  validateOptionalField(tx, 'AssetScale', isNumber)
 
   if (typeof tx.MPTokenMetadata === 'string' && tx.MPTokenMetadata === '') {
     throw new ValidationError(
@@ -129,4 +142,39 @@ export function validateMPTokenIssuanceCreate(
       'MPTokenIssuanceCreate: MPTokenMetadata must be in hex format',
     )
   }
+
+  if (typeof tx.MaximumAmount === 'string') {
+    if (!INTEGER_SANITY_CHECK.exec(tx.MaximumAmount)) {
+      throw new ValidationError('MPTokenIssuanceCreate: Invalid MaximumAmount')
+    } else if (
+      BigInt(tx.MaximumAmount) > BigInt(MAX_AMT) ||
+      BigInt(tx.MaximumAmount) < BigInt(`0`)
+    ) {
+      throw new ValidationError(
+        'MPTokenIssuanceCreate: MaximumAmount out of range',
+      )
+    }
+  }
+
+  if (typeof tx.TransferFee === 'number') {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Not necessary
+    const flags = tx.Flags as number | MPTokenIssuanceCreateFlagsInterface
+    const isTfMPTCanTransfer =
+      typeof flags === 'number'
+        ? isFlagEnabled(flags, MPTokenIssuanceCreateFlags.tfMPTCanTransfer)
+        : flags.tfMPTCanTransfer ?? false
+
+    if (tx.TransferFee < 0 || tx.TransferFee > MAX_TRANSFER_FEE) {
+      throw new ValidationError(
+        `MPTokenIssuanceCreate: TransferFee must be between 0 and ${MAX_TRANSFER_FEE}`,
+      )
+    }
+
+    if (tx.TransferFee && !isTfMPTCanTransfer) {
+      throw new ValidationError(
+        'MPTokenIssuanceCreate: TransferFee cannot be provided without enabling tfMPTCanTransfer flag',
+      )
+    }
+  }
 }
+/* eslint-enable max-lines-per-function */

package/src/models/transactions/MPTokenIssuanceSet.ts

@@ -1,3 +1,6 @@
+import { ValidationError } from '../../errors'
+import { isFlagEnabled } from '../utils'
+
 import {
   BaseTransaction,
   isString,
@@ -6,9 +9,8 @@ import {
   Account,
   validateOptionalField,
   isAccount,
-  GlobalFlags,
+  GlobalFlagsInterface,
 } from './common'
-import { ValidationError } from '../../errors'
 
 /**
  * Transaction Flags for an MPTokenIssuanceSet Transaction.
@@ -32,7 +34,7 @@ export enum MPTokenIssuanceSetFlags {
  *
  * @category Transaction Flags
  */
-export interface MPTokenIssuanceSetFlagsInterface extends GlobalFlags {
+export interface MPTokenIssuanceSetFlagsInterface extends GlobalFlagsInterface {
   tfMPTLock?: boolean
   tfMPTUnlock?: boolean
 }
@@ -51,7 +53,7 @@ export interface MPTokenIssuanceSet extends BaseTransaction {
    * An optional XRPL Address of an individual token holder balance to lock/unlock.
    * If omitted, this transaction will apply to all any accounts holding MPTs.
    */
-  MPTokenHolder?: Account
+  Holder?: Account
   Flags?: number | MPTokenIssuanceSetFlagsInterface
 }
 
@@ -64,13 +66,21 @@ export interface MPTokenIssuanceSet extends BaseTransaction {
 export function validateMPTokenIssuanceSet(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
   validateRequiredField(tx, 'MPTokenIssuanceID', isString)
-  validateOptionalField(tx, 'MPTokenHolder', isAccount)
+  validateOptionalField(tx, 'Holder', isAccount)
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Not necessary
+  const flags = tx.Flags as number | MPTokenIssuanceSetFlagsInterface
+  const isTfMPTLock =
+    typeof flags === 'number'
+      ? isFlagEnabled(flags, MPTokenIssuanceSetFlags.tfMPTLock)
+      : flags.tfMPTLock ?? false
+
+  const isTfMPTUnlock =
+    typeof flags === 'number'
+      ? isFlagEnabled(flags, MPTokenIssuanceSetFlags.tfMPTUnlock)
+      : flags.tfMPTUnlock ?? false
 
-  const flags = tx.Flags as number
-  if (
-    BigInt(flags) & BigInt(MPTokenIssuanceSetFlags.tfMPTLock) &&
-    BigInt(flags) & BigInt(MPTokenIssuanceSetFlags.tfMPTUnlock)
-  ) {
+  if (isTfMPTLock && isTfMPTUnlock) {
     throw new ValidationError('MPTokenIssuanceSet: flag conflict')
   }
 }

package/src/models/transactions/NFTokenCreateOffer.ts

@@ -4,7 +4,7 @@ import { isFlagEnabled } from '../utils'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   validateBaseTransaction,
   isAmount,
   parseAmountValue,
@@ -33,7 +33,7 @@ export enum NFTokenCreateOfferFlags {
  *
  * @category Transaction Flags
  */
-export interface NFTokenCreateOfferFlagsInterface extends GlobalFlags {
+export interface NFTokenCreateOfferFlagsInterface extends GlobalFlagsInterface {
   tfSellNFToken?: boolean
 }
 

package/src/models/transactions/NFTokenMint.ts

@@ -4,7 +4,7 @@ import { isHex } from '../utils'
 import {
   Account,
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAccount,
   validateBaseTransaction,
   validateOptionalField,
@@ -38,6 +38,10 @@ export enum NFTokenMintFlags {
    * issuer.
    */
   tfTransferable = 0x00000008,
+  /**
+   * If set, indicates that this NFT's URI can be modified.
+   */
+  tfMutable = 0x00000010,
 }
 
 /**
@@ -46,11 +50,12 @@ export enum NFTokenMintFlags {
  *
  * @category Transaction Flags
  */
-export interface NFTokenMintFlagsInterface extends GlobalFlags {
+export interface NFTokenMintFlagsInterface extends GlobalFlagsInterface {
   tfBurnable?: boolean
   tfOnlyXRP?: boolean
   tfTrustLine?: boolean
   tfTransferable?: boolean
+  tfMutable?: boolean
 }
 
 /**

package/src/models/transactions/NFTokenModify.ts

@@ -0,0 +1,67 @@
+import { ValidationError } from '../../errors'
+import { isHex } from '../utils'
+
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  isAccount,
+  isString,
+  validateOptionalField,
+  Account,
+  validateRequiredField,
+} from './common'
+
+/**
+ * The NFTokenModify transaction modifies an NFToken's URI
+ * if its tfMutable is set to true.
+ */
+export interface NFTokenModify extends BaseTransaction {
+  TransactionType: 'NFTokenModify'
+  /**
+   * Identifies the NFTokenID of the NFToken object that the
+   * offer references.
+   */
+  NFTokenID: string
+  /**
+   * Indicates the AccountID of the account that owns the corresponding NFToken.
+   * Can be omitted if the owner is the account submitting this transaction
+   */
+  Owner?: Account
+  /**
+   * URI that points to the data and/or metadata associated with the NFT.
+   * This field need not be an HTTP or HTTPS URL; it could be an IPFS URI, a
+   * magnet link, immediate data encoded as an RFC2379 "data" URL, or even an
+   * opaque issuer-specific encoding. The URI is NOT checked for validity, but
+   * the field is limited to a maximum length of 256 bytes.
+   *
+   * This field must be hex-encoded. You can use `convertStringToHex` to
+   * convert this field to the proper encoding.
+   *
+   * This field must not be an empty string. Omit it from the transaction or
+   * set to `null` if you do not use it.
+   */
+  URI?: string | null
+}
+
+/**
+ * Verify the form and type of an NFTokenModify at runtime.
+ *
+ * @param tx - An NFTokenModify Transaction.
+ * @throws When the NFTokenModify is Malformed.
+ */
+export function validateNFTokenModify(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'NFTokenID', isString)
+  validateOptionalField(tx, 'Owner', isAccount)
+  validateOptionalField(tx, 'URI', isString)
+
+  if (tx.URI !== undefined && typeof tx.URI === 'string') {
+    if (tx.URI === '') {
+      throw new ValidationError('NFTokenModify: URI must not be empty string')
+    }
+    if (!isHex(tx.URI)) {
+      throw new ValidationError('NFTokenModify: URI must be in hex format')
+    }
+  }
+}

package/src/models/transactions/XChainModifyBridge.ts

@@ -2,7 +2,7 @@ import { Amount, XChainBridge } from '../common'
 
 import {
   BaseTransaction,
-  GlobalFlags,
+  GlobalFlagsInterface,
   isAmount,
   isXChainBridge,
   validateBaseTransaction,
@@ -26,7 +26,7 @@ export enum XChainModifyBridgeFlags {
  *
  * @category Transaction Flags
  */
-export interface XChainModifyBridgeFlagsInterface extends GlobalFlags {
+export interface XChainModifyBridgeFlagsInterface extends GlobalFlagsInterface {
   /** Clears the MinAccountCreateAmount of the bridge. */
   tfClearAccountCreateAmount?: boolean
 }

package/src/models/transactions/accountDelete.ts

@@ -4,8 +4,10 @@ import {
   isAccount,
   isNumber,
   validateBaseTransaction,
+  validateCredentialsList,
   validateOptionalField,
   validateRequiredField,
+  MAX_AUTHORIZED_CREDENTIALS,
 } from './common'
 
 /**
@@ -28,6 +30,12 @@ export interface AccountDelete extends BaseTransaction {
    * information for the recipient of the deleted account's leftover XRP.
    */
   DestinationTag?: number
+  /**
+   * Credentials associated with sender of this transaction. The credentials included
+   * must not be expired. The list must not be empty when specified and cannot contain
+   * more than 8 credentials.
+   */
+  CredentialIDs?: string[]
 }
 
 /**
@@ -41,4 +49,12 @@ export function validateAccountDelete(tx: Record<string, unknown>): void {
 
   validateRequiredField(tx, 'Destination', isAccount)
   validateOptionalField(tx, 'DestinationTag', isNumber)
+
+  validateCredentialsList(
+    tx.CredentialIDs,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- known from base check
+    tx.TransactionType as string,
+    true,
+    MAX_AUTHORIZED_CREDENTIALS,
+  )
 }

package/src/models/transactions/accountSet.ts

@@ -3,6 +3,7 @@ import { ValidationError } from '../../errors'
 import {
   Account,
   BaseTransaction,
+  GlobalFlagsInterface,
   isAccount,
   validateBaseTransaction,
   validateOptionalField,
@@ -112,7 +113,7 @@ export enum AccountSetTfFlags {
  * // }
  * ```
  */
-export interface AccountSetFlagsInterface {
+export interface AccountSetFlagsInterface extends GlobalFlagsInterface {
   tfRequireDestTag?: boolean
   tfOptionalDestTag?: boolean
   tfRequireAuth?: boolean