xrpl 1.0.0-mpt-beta

package/src/models/transactions/MPTokenAuthorize.ts

@@ -0,0 +1,67 @@
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField,
+  Account,
+  validateOptionalField,
+  isAccount,
+  GlobalFlags,
+} from './common'
+
+/**
+ * Transaction Flags for an MPTokenAuthorize Transaction.
+ *
+ * @category Transaction Flags
+ */
+export enum MPTokenAuthorizeFlags {
+  /**
+   * If set and transaction is submitted by a holder, it indicates that the holder no
+   * longer wants to hold the MPToken, which will be deleted as a result. If the the holder's
+   * MPToken has non-zero balance while trying to set this flag, the transaction will fail. On
+   * the other hand, if set and transaction is submitted by an issuer, it would mean that the
+   * issuer wants to unauthorize the holder (only applicable for allow-listing),
+   * which would unset the lsfMPTAuthorized flag on the MPToken.
+   */
+  tfMPTUnauthorize = 0x00000001,
+}
+
+/**
+ * Map of flags to boolean values representing {@link MPTokenAuthorize} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface MPTokenAuthorizeFlagsInterface extends GlobalFlags {
+  tfMPTUnauthorize?: boolean
+}
+
+/**
+ * The MPTokenAuthorize transaction is used to globally lock/unlock a MPTokenIssuance,
+ * or lock/unlock an individual's MPToken.
+ */
+export interface MPTokenAuthorize extends BaseTransaction {
+  TransactionType: 'MPTokenAuthorize'
+  /**
+   * Identifies the MPTokenIssuance
+   */
+  MPTokenIssuanceID: string
+  /**
+   * 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
+  Flags?: number | MPTokenAuthorizeFlagsInterface
+}
+
+/**
+ * Verify the form and type of an MPTokenAuthorize at runtime.
+ *
+ * @param tx - An MPTokenAuthorize Transaction.
+ * @throws When the MPTokenAuthorize is Malformed.
+ */
+export function validateMPTokenAuthorize(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+  validateRequiredField(tx, 'MPTokenIssuanceID', isString)
+  validateOptionalField(tx, 'MPTokenHolder', isAccount)
+}

package/src/models/transactions/MPTokenIssuanceCreate.ts

@@ -0,0 +1,123 @@
+import { ValidationError } from '../../errors'
+import { isHex } from '../utils'
+
+import { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'
+import type { TransactionMetadataBase } from './metadata'
+
+/**
+ * Transaction Flags for an MPTokenIssuanceCreate Transaction.
+ *
+ * @category Transaction Flags
+ */
+export enum MPTokenIssuanceCreateFlags {
+  /**
+   * If set, indicates that the MPT can be locked both individually and globally.
+   * If not set, the MPT cannot be locked in any way.
+   */
+  tfMPTCanLock = 0x00000002,
+  /**
+   * If set, indicates that individual holders must be authorized.
+   * This enables issuers to limit who can hold their assets.
+   */
+  tfMPTRequireAuth = 0x00000004,
+  /**
+   * If set, indicates that individual holders can place their balances into an escrow.
+   */
+  tfMPTCanEscrow = 0x00000008,
+  /**
+   * 	If set, indicates that individual holders can trade their balances
+   *  using the XRP Ledger DEX or AMM.
+   */
+  tfMPTCanTrade = 0x00000010,
+  /**
+   * If set, indicates that tokens may be transferred to other accounts
+   *  that are not the issuer.
+   */
+  tfMPTCanTransfer = 0x00000020,
+  /**
+   * If set, indicates that the issuer may use the Clawback transaction
+   * to clawback value from individual holders.
+   */
+  tfMPTCanClawback = 0x00000040,
+}
+
+/**
+ * Map of flags to boolean values representing {@link MPTokenIssuanceCreate} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface MPTokenIssuanceCreateFlagsInterface extends GlobalFlags {
+  tfMPTCanLock?: boolean
+  tfMPTRequireAuth?: boolean
+  tfMPTCanEscrow?: boolean
+  tfMPTCanTrade?: boolean
+  tfMPTCanTransfer?: boolean
+  tfMPTCanClawback?: boolean
+}
+
+/**
+ * The MPTokenIssuanceCreate transaction creates a MPTokenIssuance object
+ * and adds it to the relevant directory node of the creator account.
+ * This transaction is the only opportunity an issuer has to specify any token fields
+ * that are defined as immutable (e.g., MPT Flags). If the transaction is successful,
+ * the newly created token will be owned by the account (the creator account) which
+ * executed the transaction.
+ */
+export interface MPTokenIssuanceCreate extends BaseTransaction {
+  TransactionType: 'MPTokenIssuanceCreate'
+  /**
+   * An asset scale is the difference, in orders of magnitude, between a standard unit and
+   * a corresponding fractional unit. More formally, the asset scale is a non-negative integer
+   * (0, 1, 2, …) such that one standard unit equals 10^(-scale) of a corresponding
+   * fractional unit. If the fractional unit equals the standard unit, then the asset scale is 0.
+   * Note that this value is optional, and will default to 0 if not supplied.
+   */
+  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)
+   */
+  MaximumAmount?: string
+  /**
+   * Specifies the fee to charged by the issuer for secondary sales of the Token,
+   * if such sales are allowed. Valid values for this field are between 0 and 50,000 inclusive,
+   * allowing transfer rates of between 0.000% and 50.000% in increments of 0.001.
+   * The field must NOT be present if the `tfMPTCanTransfer` flag is not set.
+   */
+  TransferFee?: number
+  /**
+   * Arbitrary metadata about this issuance, in hex format.
+   */
+  MPTokenMetadata?: string | null
+  Flags?: number | MPTokenIssuanceCreateFlagsInterface
+}
+
+export interface MPTokenIssuanceCreateMetadata extends TransactionMetadataBase {
+  mpt_issuance_id?: string
+}
+
+/**
+ * Verify the form and type of an MPTokenIssuanceCreate at runtime.
+ *
+ * @param tx - An MPTokenIssuanceCreate Transaction.
+ * @throws When the MPTokenIssuanceCreate is Malformed.
+ */
+export function validateMPTokenIssuanceCreate(
+  tx: Record<string, unknown>,
+): void {
+  validateBaseTransaction(tx)
+
+  if (typeof tx.MPTokenMetadata === 'string' && tx.MPTokenMetadata === '') {
+    throw new ValidationError(
+      'MPTokenIssuanceCreate: MPTokenMetadata must not be empty string',
+    )
+  }
+
+  if (typeof tx.MPTokenMetadata === 'string' && !isHex(tx.MPTokenMetadata)) {
+    throw new ValidationError(
+      'MPTokenIssuanceCreate: MPTokenMetadata must be in hex format',
+    )
+  }
+}

package/src/models/transactions/MPTokenIssuanceDestroy.ts

@@ -0,0 +1,34 @@
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField,
+} from './common'
+
+/**
+ * The MPTokenIssuanceDestroy transaction is used to remove an MPTokenIssuance object
+ * from the directory node in which it is being held, effectively removing the token
+ * from the ledger. If this operation succeeds, the corresponding
+ * MPTokenIssuance is removed and the owner’s reserve requirement is reduced by one.
+ * This operation must fail if there are any holders who have non-zero balances.
+ */
+export interface MPTokenIssuanceDestroy extends BaseTransaction {
+  TransactionType: 'MPTokenIssuanceDestroy'
+  /**
+   * Identifies the MPTokenIssuance object to be removed by the transaction.
+   */
+  MPTokenIssuanceID: string
+}
+
+/**
+ * Verify the form and type of an MPTokenIssuanceDestroy at runtime.
+ *
+ * @param tx - An MPTokenIssuanceDestroy Transaction.
+ * @throws When the MPTokenIssuanceDestroy is Malformed.
+ */
+export function validateMPTokenIssuanceDestroy(
+  tx: Record<string, unknown>,
+): void {
+  validateBaseTransaction(tx)
+  validateRequiredField(tx, 'MPTokenIssuanceID', isString)
+}

package/src/models/transactions/MPTokenIssuanceSet.ts

@@ -0,0 +1,78 @@
+import {
+  BaseTransaction,
+  isString,
+  validateBaseTransaction,
+  validateRequiredField,
+  Account,
+  validateOptionalField,
+  isAccount,
+  GlobalFlags,
+} from './common'
+import { ValidationError } from '../../errors'
+
+/**
+ * Transaction Flags for an MPTokenIssuanceSet Transaction.
+ *
+ * @category Transaction Flags
+ */
+export enum MPTokenIssuanceSetFlags {
+  /**
+   * If set, indicates that the MPT can be locked both individually and globally.
+   * If not set, the MPT cannot be locked in any way.
+   */
+  tfMPTLock = 0x00000001,
+  /**
+   * If set, indicates that the MPT can be locked both individually and globally.
+   * If not set, the MPT cannot be locked in any way.
+   */
+  tfMPTUnlock = 0x00000002,
+}
+
+/**
+ * Map of flags to boolean values representing {@link MPTokenIssuanceSet} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface MPTokenIssuanceSetFlagsInterface extends GlobalFlags {
+  tfMPTLock?: boolean
+  tfMPTUnlock?: boolean
+}
+
+/**
+ * The MPTokenIssuanceSet transaction is used to globally lock/unlock a MPTokenIssuance,
+ * or lock/unlock an individual's MPToken.
+ */
+export interface MPTokenIssuanceSet extends BaseTransaction {
+  TransactionType: 'MPTokenIssuanceSet'
+  /**
+   * Identifies the MPTokenIssuance
+   */
+  MPTokenIssuanceID: string
+  /**
+   * 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
+  Flags?: number | MPTokenIssuanceSetFlagsInterface
+}
+
+/**
+ * Verify the form and type of an MPTokenIssuanceSet at runtime.
+ *
+ * @param tx - An MPTokenIssuanceSet Transaction.
+ * @throws When the MPTokenIssuanceSet is Malformed.
+ */
+export function validateMPTokenIssuanceSet(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+  validateRequiredField(tx, 'MPTokenIssuanceID', isString)
+  validateOptionalField(tx, 'MPTokenHolder', isAccount)
+
+  const flags = tx.Flags as number
+  if (
+    BigInt(flags) & BigInt(MPTokenIssuanceSetFlags.tfMPTLock) &&
+    BigInt(flags) & BigInt(MPTokenIssuanceSetFlags.tfMPTUnlock)
+  ) {
+    throw new ValidationError('MPTokenIssuanceSet: flag conflict')
+  }
+}

package/src/models/transactions/NFTokenAcceptOffer.ts

@@ -0,0 +1,110 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+
+import {
+  BaseTransaction,
+  parseAmountValue,
+  validateBaseTransaction,
+} from './common'
+import type { TransactionMetadataBase } from './metadata'
+
+/**
+ *  The NFTokenOfferAccept transaction is used to accept offers
+ *  to buy or sell an NFToken. It can either:
+ *
+ *  1. Allow one offer to be accepted. This is called direct
+ *     mode.
+ *  2. Allow two distinct offers, one offering to buy a
+ *     given NFToken and the other offering to sell the same
+ *     NFToken, to be accepted in an atomic fashion. This is
+ *     called brokered mode.
+ *
+ *  To indicate direct mode, use either the `sell_offer` or
+ *  `buy_offer` fields, but not both. To indicate brokered mode,
+ *  use both the `sell_offer` and `buy_offer` fields. If you use
+ *  neither `sell_offer` nor `buy_offer`, the transaction is invalid.
+ */
+export interface NFTokenAcceptOffer extends BaseTransaction {
+  TransactionType: 'NFTokenAcceptOffer'
+  /**
+   *  Identifies the NFTokenOffer that offers to sell the NFToken.
+   *
+   *  In direct mode this field is optional, but either NFTokenSellOffer or
+   *  NFTokenBuyOffer must be specified. In brokered mode, both NFTokenSellOffer
+   *  and NFTokenBuyOffer must be specified.
+   */
+  NFTokenSellOffer?: string
+  /**
+   * Identifies the NFTokenOffer that offers to buy the NFToken.
+   *
+   * In direct mode this field is optional, but either NFTokenSellOffer or
+   * NFTokenBuyOffer must be specified. In brokered mode, both NFTokenSellOffer
+   * and NFTokenBuyOffer must be specified.
+   */
+  NFTokenBuyOffer?: string
+  /**
+   * This field is only valid in brokered mode. It specifies the
+   * amount that the broker will keep as part of their fee for
+   * bringing the two offers together; the remaining amount will
+   * be sent to the seller of the NFToken being bought. If
+   * specified, the fee must be such that, prior to accounting
+   * for the transfer fee charged by the issuer, the amount that
+   * the seller would receive is at least as much as the amount
+   * indicated in the sell offer.
+   *
+   * This functionality is intended to allow the owner of an
+   * NFToken to offer their token for sale to a third party
+   * broker, who may then attempt to sell the NFToken on for a
+   * larger amount, without the broker having to own the NFToken
+   * or custody funds.
+   *
+   * Note: in brokered mode, the offers referenced by NFTokenBuyOffer
+   * and NFTokenSellOffer must both specify the same NFTokenID; that is,
+   * both must be for the same NFToken.
+   */
+  NFTokenBrokerFee?: Amount
+}
+
+export interface NFTokenAcceptOfferMetadata extends TransactionMetadataBase {
+  // rippled 1.11.0 or later
+  nftoken_id?: string
+}
+
+function validateNFTokenBrokerFee(tx: Record<string, unknown>): void {
+  const value = parseAmountValue(tx.NFTokenBrokerFee)
+  if (Number.isNaN(value)) {
+    throw new ValidationError('NFTokenAcceptOffer: invalid NFTokenBrokerFee')
+  }
+
+  if (value <= 0) {
+    throw new ValidationError(
+      'NFTokenAcceptOffer: NFTokenBrokerFee must be greater than 0; omit if there is no fee',
+    )
+  }
+
+  if (tx.NFTokenSellOffer == null || tx.NFTokenBuyOffer == null) {
+    throw new ValidationError(
+      'NFTokenAcceptOffer: both NFTokenSellOffer and NFTokenBuyOffer must be set if using brokered mode',
+    )
+  }
+}
+
+/**
+ * Verify the form and type of an NFTokenAcceptOffer at runtime.
+ *
+ * @param tx - An NFTokenAcceptOffer Transaction.
+ * @throws When the NFTokenAcceptOffer is Malformed.
+ */
+export function validateNFTokenAcceptOffer(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.NFTokenBrokerFee != null) {
+    validateNFTokenBrokerFee(tx)
+  }
+
+  if (tx.NFTokenSellOffer == null && tx.NFTokenBuyOffer == null) {
+    throw new ValidationError(
+      'NFTokenAcceptOffer: must set either NFTokenSellOffer or NFTokenBuyOffer',
+    )
+  }
+}

package/src/models/transactions/NFTokenBurn.ts

@@ -0,0 +1,52 @@
+import {
+  Account,
+  BaseTransaction,
+  isAccount,
+  isString,
+  validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+/**
+ * The NFTokenBurn transaction is used to remove an NFToken object from the
+ * NFTokenPage in which it is being held, effectively removing the token from
+ * the ledger ("burning" it).
+ *
+ * If this operation succeeds, the corresponding NFToken is removed. If this
+ * operation empties the NFTokenPage holding the NFToken or results in the
+ * consolidation, thus removing an NFTokenPage, the owner’s reserve requirement
+ * is reduced by one.
+ */
+export interface NFTokenBurn extends BaseTransaction {
+  TransactionType: 'NFTokenBurn'
+  /**
+   * Indicates the AccountID that submitted this transaction. The account MUST
+   * be either the present owner of the token or, if the lsfBurnable flag is set
+   * in the NFToken, either the issuer account or an account authorized by the
+   * issuer, i.e. MintAccount.
+   */
+  Account: Account
+  /**
+   * Identifies the NFToken object to be removed by the transaction.
+   */
+  NFTokenID: string
+  /**
+   * Indicates which account currently owns the token if it is different than
+   * Account. Only used to burn tokens which have the lsfBurnable flag enabled
+   * and are not owned by the signing account.
+   */
+  Owner?: Account
+}
+
+/**
+ * Verify the form and type of an NFTokenBurn at runtime.
+ *
+ * @param tx - An NFTokenBurn Transaction.
+ * @throws When the NFTokenBurn is Malformed.
+ */
+export function validateNFTokenBurn(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+  validateRequiredField(tx, 'NFTokenID', isString)
+  validateOptionalField(tx, 'Owner', isAccount)
+}

package/src/models/transactions/NFTokenCancelOffer.ts

@@ -0,0 +1,51 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+import type { TransactionMetadataBase } from './metadata'
+
+/**
+ * The NFTokenCancelOffer transaction deletes existing NFTokenOffer objects.
+ * It is useful if you want to free up space on your account to lower your
+ * reserve requirement.
+ *
+ * The transaction can be executed by the account that originally created
+ * the NFTokenOffer, the account in the `Recipient` field of the NFTokenOffer
+ * (if present), or any account if the NFTokenOffer has an `Expiration` and
+ * the NFTokenOffer has already expired.
+ */
+export interface NFTokenCancelOffer extends BaseTransaction {
+  TransactionType: 'NFTokenCancelOffer'
+  /**
+   * An array of identifiers of NFTokenOffer objects that should be cancelled
+   * by this transaction.
+   *
+   * It is an error if an entry in this list points to an
+   * object that is not an NFTokenOffer object. It is not an
+   * error if an entry in this list points to an object that
+   * does not exist. This field is required.
+   */
+  NFTokenOffers: string[]
+}
+
+export interface NFTokenCancelOfferMetadata extends TransactionMetadataBase {
+  // rippled 1.11.0  or  later
+  nftoken_ids?: string[]
+}
+
+/**
+ * Verify the form and type of an NFTokenCancelOffer at runtime.
+ *
+ * @param tx - An NFTokenCancelOffer Transaction.
+ * @throws When the NFTokenCancelOffer is Malformed.
+ */
+export function validateNFTokenCancelOffer(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (!Array.isArray(tx.NFTokenOffers)) {
+    throw new ValidationError('NFTokenCancelOffer: missing field NFTokenOffers')
+  }
+
+  if (tx.NFTokenOffers.length < 1) {
+    throw new ValidationError('NFTokenCancelOffer: empty field NFTokenOffers')
+  }
+}

package/src/models/transactions/NFTokenCreateOffer.ts

@@ -0,0 +1,157 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+import { isFlagEnabled } from '../utils'
+
+import {
+  BaseTransaction,
+  GlobalFlags,
+  validateBaseTransaction,
+  isAmount,
+  parseAmountValue,
+  isAccount,
+  validateOptionalField,
+  Account,
+} from './common'
+import type { TransactionMetadataBase } from './metadata'
+
+/**
+ * Transaction Flags for an NFTokenCreateOffer Transaction.
+ *
+ * @category Transaction Flags
+ */
+export enum NFTokenCreateOfferFlags {
+  /**
+   * If set, indicates that the offer is a sell offer.
+   * Otherwise, it is a buy offer.
+   */
+  tfSellNFToken = 0x00000001,
+}
+
+/**
+ * Map of flags to boolean values representing {@link NFTokenCreateOffer} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface NFTokenCreateOfferFlagsInterface extends GlobalFlags {
+  tfSellNFToken?: boolean
+}
+
+/**
+ * The NFTokenCreateOffer transaction creates either an offer to buy an
+ * NFT the submitting account does not own, or an offer to sell an NFT
+ * the submitting account does own.
+ */
+export interface NFTokenCreateOffer extends BaseTransaction {
+  TransactionType: 'NFTokenCreateOffer'
+  /**
+   * Identifies the NFTokenID of the NFToken object that the
+   * offer references.
+   */
+  NFTokenID: string
+  /**
+   * Indicates the amount expected or offered for the Token.
+   *
+   * The amount must be non-zero, except when this is a sell
+   * offer and the asset is XRP. This would indicate that the current
+   * owner of the token is giving it away free, either to anyone at all,
+   * or to the account identified by the Destination field.
+   */
+  Amount: Amount
+  /**
+   * Indicates the AccountID of the account that owns the
+   * corresponding NFToken.
+   *
+   * If the offer is to buy a token, this field must be present
+   * and it must be different than Account (since an offer to
+   * buy a token one already holds is meaningless).
+   *
+   * If the offer is to sell a token, this field must not be
+   * present, as the owner is, implicitly, the same as Account
+   * (since an offer to sell a token one doesn't already hold
+   * is meaningless).
+   */
+  Owner?: Account
+  /**
+   * Indicates the time after which the offer will no longer
+   * be valid. The value is the number of seconds since the
+   * Ripple Epoch.
+   */
+  Expiration?: number
+  /**
+   * If present, indicates that this offer may only be
+   * accepted by the specified account. Attempts by other
+   * accounts to accept this offer MUST fail.
+   */
+  Destination?: Account
+  Flags?: number | NFTokenCreateOfferFlagsInterface
+}
+
+export interface NFTokenCreateOfferMetadata extends TransactionMetadataBase {
+  // rippled 1.11.0 or later
+  offer_id?: string
+}
+
+function validateNFTokenSellOfferCases(tx: Record<string, unknown>): void {
+  if (tx.Owner != null) {
+    throw new ValidationError(
+      'NFTokenCreateOffer: Owner must not be present for sell offers',
+    )
+  }
+}
+
+function validateNFTokenBuyOfferCases(tx: Record<string, unknown>): void {
+  if (tx.Owner == null) {
+    throw new ValidationError(
+      'NFTokenCreateOffer: Owner must be present for buy offers',
+    )
+  }
+
+  if (parseAmountValue(tx.Amount) <= 0) {
+    throw new ValidationError(
+      'NFTokenCreateOffer: Amount must be greater than 0 for buy offers',
+    )
+  }
+}
+
+/**
+ * Verify the form and type of an NFTokenCreateOffer at runtime.
+ *
+ * @param tx - An NFTokenCreateOffer Transaction.
+ * @throws When the NFTokenCreateOffer is Malformed.
+ */
+export function validateNFTokenCreateOffer(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Account === tx.Owner) {
+    throw new ValidationError(
+      'NFTokenCreateOffer: Owner and Account must not be equal',
+    )
+  }
+
+  if (tx.Account === tx.Destination) {
+    throw new ValidationError(
+      'NFTokenCreateOffer: Destination and Account must not be equal',
+    )
+  }
+
+  validateOptionalField(tx, 'Destination', isAccount)
+  validateOptionalField(tx, 'Owner', isAccount)
+
+  if (tx.NFTokenID == null) {
+    throw new ValidationError('NFTokenCreateOffer: missing field NFTokenID')
+  }
+
+  if (!isAmount(tx.Amount)) {
+    throw new ValidationError('NFTokenCreateOffer: invalid Amount')
+  }
+
+  if (
+    typeof tx.Flags === 'number' &&
+    isFlagEnabled(tx.Flags, NFTokenCreateOfferFlags.tfSellNFToken)
+  ) {
+    validateNFTokenSellOfferCases(tx)
+  } else {
+    validateNFTokenBuyOfferCases(tx)
+  }
+}