xrpl 1.0.0-mpt-beta

package/src/models/transactions/XChainCreateClaimID.ts

@@ -0,0 +1,54 @@
+import { Amount, XChainBridge } from '../common'
+
+import {
+  Account,
+  BaseTransaction,
+  isAccount,
+  isAmount,
+  isXChainBridge,
+  validateBaseTransaction,
+  validateRequiredField,
+} from './common'
+
+/**
+ * The XChainCreateClaimID transaction creates a new cross-chain claim ID that is
+ * used for a cross-chain transfer. A cross-chain claim ID represents one
+ * cross-chain transfer of value.
+ *
+ * @category Transaction Models
+ */
+export interface XChainCreateClaimID extends BaseTransaction {
+  TransactionType: 'XChainCreateClaimID'
+
+  /**
+   * The bridge to create the claim ID for.
+   */
+  XChainBridge: XChainBridge
+
+  /**
+   * The amount, in XRP, to reward the witness servers for providing signatures.
+   * This must match the amount on the {@link Bridge} ledger object.
+   */
+  SignatureReward: Amount
+
+  /**
+   * The account that must send the {@link XChainCommit} transaction on the source chain.
+   */
+  OtherChainSource: Account
+}
+
+/**
+ * Verify the form and type of an XChainCreateClaimID at runtime.
+ *
+ * @param tx - An XChainCreateClaimID Transaction.
+ * @throws When the XChainCreateClaimID is malformed.
+ */
+export function validateXChainCreateClaimID(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'XChainBridge', isXChainBridge)
+
+  validateRequiredField(tx, 'SignatureReward', isAmount)
+
+  validateRequiredField(tx, 'OtherChainSource', isAccount)
+}

package/src/models/transactions/XChainModifyBridge.ts

@@ -0,0 +1,77 @@
+import { Amount, XChainBridge } from '../common'
+
+import {
+  BaseTransaction,
+  GlobalFlags,
+  isAmount,
+  isXChainBridge,
+  validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+/**
+ * Enum representing values of {@link XChainModifyBridge} transaction flags.
+ *
+ * @category Transaction Flags
+ */
+export enum XChainModifyBridgeFlags {
+  /** Clears the MinAccountCreateAmount of the bridge. */
+  tfClearAccountCreateAmount = 0x00010000,
+}
+
+/**
+ * Map of flags to boolean values representing {@link XChainModifyBridge} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ */
+export interface XChainModifyBridgeFlagsInterface extends GlobalFlags {
+  /** Clears the MinAccountCreateAmount of the bridge. */
+  tfClearAccountCreateAmount?: boolean
+}
+
+/**
+ * The XChainModifyBridge transaction allows bridge managers to modify the parameters
+ * of the bridge.
+ *
+ * @category Transaction Models
+ */
+export interface XChainModifyBridge extends BaseTransaction {
+  TransactionType: 'XChainModifyBridge'
+
+  /**
+   * The bridge to modify.
+   */
+  XChainBridge: XChainBridge
+
+  /**
+   * The signature reward split between the witnesses for submitting attestations.
+   */
+  SignatureReward?: Amount
+
+  /**
+   * The minimum amount, in XRP, required for a {@link XChainAccountCreateCommit}
+   * transaction. If this is not present, the {@link XChainAccountCreateCommit}
+   * transaction will fail. This field can only be present on XRP-XRP bridges.
+   */
+  MinAccountCreateAmount?: Amount
+
+  Flags?: number | XChainModifyBridgeFlagsInterface
+}
+
+/**
+ * Verify the form and type of an XChainModifyBridge at runtime.
+ *
+ * @param tx - An XChainModifyBridge Transaction.
+ * @throws When the XChainModifyBridge is malformed.
+ */
+export function validateXChainModifyBridge(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'XChainBridge', isXChainBridge)
+
+  validateOptionalField(tx, 'SignatureReward', isAmount)
+
+  validateOptionalField(tx, 'MinAccountCreateAmount', isAmount)
+}

package/src/models/transactions/accountDelete.ts

@@ -0,0 +1,44 @@
+import {
+  Account,
+  BaseTransaction,
+  isAccount,
+  isNumber,
+  validateBaseTransaction,
+  validateOptionalField,
+  validateRequiredField,
+} from './common'
+
+/**
+ * An AccountDelete transaction deletes an account and any objects it owns in
+ * the XRP Ledger, if possible, sending the account's remaining XRP to a
+ * specified destination account.
+ *
+ * @category Transaction Models
+ */
+export interface AccountDelete extends BaseTransaction {
+  TransactionType: 'AccountDelete'
+  /**
+   * The address of an account to receive any leftover XRP after deleting the
+   * sending account. Must be a funded account in the ledger, and must not be.
+   * the sending account.
+   */
+  Destination: Account
+  /**
+   * Arbitrary destination tag that identifies a hosted recipient or other.
+   * information for the recipient of the deleted account's leftover XRP.
+   */
+  DestinationTag?: number
+}
+
+/**
+ * Verify the form and type of an AccountDelete at runtime.
+ *
+ * @param tx - An AccountDelete Transaction.
+ * @throws When the AccountDelete is Malformed.
+ */
+export function validateAccountDelete(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateRequiredField(tx, 'Destination', isAccount)
+  validateOptionalField(tx, 'DestinationTag', isNumber)
+}

package/src/models/transactions/accountSet.ts

@@ -0,0 +1,225 @@
+import { ValidationError } from '../../errors'
+
+import {
+  Account,
+  BaseTransaction,
+  isAccount,
+  validateBaseTransaction,
+  validateOptionalField,
+} from './common'
+
+/**
+ * Enum for AccountSet Flags.
+ *
+ * @category Transaction Flags
+ */
+export enum AccountSetAsfFlags {
+  /** Require a destination tag to send transactions to this account. */
+  asfRequireDest = 1,
+  /**
+   * Require authorization for users to hold balances issued by this address
+   * can only be enabled if the address has no trust lines connected to it.
+   */
+  asfRequireAuth = 2,
+  /** XRP should not be sent to this account. */
+  asfDisallowXRP = 3,
+  /**
+   * Disallow use of the master key pair. Can only be enabled if the account
+   * has configured another way to sign transactions, such as a Regular Key or a
+   * Signer List.
+   */
+  asfDisableMaster = 4,
+  /**
+   * Track the ID of this account's most recent transaction. Required for
+   * AccountTxnID.
+   */
+  asfAccountTxnID = 5,
+  /**
+   * Permanently give up the ability to freeze individual trust lines or
+   * disable Global Freeze. This flag can never be disabled after being enabled.
+   */
+  asfNoFreeze = 6,
+  /** Freeze all assets issued by this account. */
+  asfGlobalFreeze = 7,
+  /** Enable rippling on this account's trust lines by default. */
+  asfDefaultRipple = 8,
+  /** Enable Deposit Authorization on this account. */
+  asfDepositAuth = 9,
+  /**
+   * Allow another account to mint and burn tokens on behalf of this account.
+   */
+  asfAuthorizedNFTokenMinter = 10,
+  /** asf 11 is reserved for Hooks amendment */
+  /** Disallow other accounts from creating incoming NFTOffers */
+  asfDisallowIncomingNFTokenOffer = 12,
+  /** Disallow other accounts from creating incoming Checks */
+  asfDisallowIncomingCheck = 13,
+  /** Disallow other accounts from creating incoming PayChannels */
+  asfDisallowIncomingPayChan = 14,
+  /** Disallow other accounts from creating incoming Trustlines */
+  asfDisallowIncomingTrustline = 15,
+  /** Permanently gain the ability to claw back issued IOUs */
+  asfAllowTrustLineClawback = 16,
+}
+
+/**
+ * Enum for AccountSet Transaction Flags.
+ *
+ * @category Transaction Flags
+ */
+export enum AccountSetTfFlags {
+  /** The same as SetFlag: asfRequireDest. */
+  tfRequireDestTag = 0x00010000,
+  /** The same as ClearFlag: asfRequireDest. */
+  tfOptionalDestTag = 0x00020000,
+  /** The same as SetFlag: asfRequireAuth. */
+  tfRequireAuth = 0x00040000,
+  /** The same as ClearFlag: asfRequireAuth. */
+  tfOptionalAuth = 0x00080000,
+  /** The same as SetFlag: asfDisallowXRP. */
+  tfDisallowXRP = 0x00100000,
+  /** The same as ClearFlag: asfDisallowXRP. */
+  tfAllowXRP = 0x00200000,
+}
+
+/**
+ * Map of flags to boolean values representing {@link AccountSet} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ *
+ * @example
+ * ```typescript
+ *  const accountSetTx: AccountSet = {
+ *    TransactionType: 'AccountSet',
+ *    Account: 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn',
+ *    Flags: {
+ *      tfOptionalDestTag: true,
+ *      tfRequireAuth: true
+ *    },
+ *  }
+ *
+ * // Autofill the tx to see how flags actually look compared to the interface usage.
+ * const autofilledTx = await client.autofill(accountSetTx)
+ * console.log(autofilledTx)
+ * // {
+ * //  TransactionType: 'AccountSet',
+ * //  Account: 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn',
+ * //  Flags: 393216,
+ * //  Sequence: 1,
+ * //  Fee: '12',
+ * //  LastLedgerSequence: 21971793
+ * // }
+ * ```
+ */
+export interface AccountSetFlagsInterface {
+  tfRequireDestTag?: boolean
+  tfOptionalDestTag?: boolean
+  tfRequireAuth?: boolean
+  tfOptionalAuth?: boolean
+  tfDisallowXRP?: boolean
+  tfAllowXRP?: boolean
+}
+
+/**
+ * An AccountSet transaction modifies the properties of an account in the XRP
+ * Ledger.
+ *
+ * @category Transaction Models
+ */
+export interface AccountSet extends BaseTransaction {
+  TransactionType: 'AccountSet'
+  Flags?: number | AccountSetFlagsInterface
+  /** Unique identifier of a flag to disable for this account. */
+  ClearFlag?: number
+  /**
+   * The domain that owns this account, as a string of hex representing the.
+   * ASCII for the domain in lowercase.
+   */
+  Domain?: string
+  /** Hash of an email address to be used for generating an avatar image. */
+  EmailHash?: string
+  /** Public key for sending encrypted messages to this account. */
+  MessageKey?: string
+  /** Integer flag to enable for this account. */
+  SetFlag?: AccountSetAsfFlags
+  /**
+   * The fee to charge when users transfer this account's issued currencies,
+   * represented as billionths of a unit. Cannot be more than 2000000000 or less
+   * than 1000000000, except for the special case 0 meaning no fee.
+   */
+  TransferRate?: number
+  /**
+   * Tick size to use for offers involving a currency issued by this address.
+   * The exchange rates of those offers is rounded to this many significant
+   * digits. Valid values are 3 to 15 inclusive, or 0 to disable.
+   */
+  TickSize?: number
+  /**
+   * Sets an alternate account that is allowed to mint NFTokens on this
+   * account's behalf using NFTokenMint's `Issuer` field.
+   */
+  NFTokenMinter?: Account
+}
+
+const MIN_TICK_SIZE = 3
+const MAX_TICK_SIZE = 15
+
+/**
+ * Verify the form and type of an AccountSet at runtime.
+ *
+ * @param tx - An AccountSet Transaction.
+ * @throws When the AccountSet is Malformed.
+ */
+// eslint-disable-next-line max-lines-per-function -- okay for this method, only a little over
+export function validateAccountSet(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  validateOptionalField(tx, 'NFTokenMinter', isAccount)
+
+  if (tx.ClearFlag !== undefined) {
+    if (typeof tx.ClearFlag !== 'number') {
+      throw new ValidationError('AccountSet: invalid ClearFlag')
+    }
+    if (!Object.values(AccountSetAsfFlags).includes(tx.ClearFlag)) {
+      throw new ValidationError('AccountSet: invalid ClearFlag')
+    }
+  }
+
+  if (tx.Domain !== undefined && typeof tx.Domain !== 'string') {
+    throw new ValidationError('AccountSet: invalid Domain')
+  }
+
+  if (tx.EmailHash !== undefined && typeof tx.EmailHash !== 'string') {
+    throw new ValidationError('AccountSet: invalid EmailHash')
+  }
+
+  if (tx.MessageKey !== undefined && typeof tx.MessageKey !== 'string') {
+    throw new ValidationError('AccountSet: invalid MessageKey')
+  }
+
+  if (tx.SetFlag !== undefined) {
+    if (typeof tx.SetFlag !== 'number') {
+      throw new ValidationError('AccountSet: invalid SetFlag')
+    }
+    if (!Object.values(AccountSetAsfFlags).includes(tx.SetFlag)) {
+      throw new ValidationError('AccountSet: invalid SetFlag')
+    }
+  }
+
+  if (tx.TransferRate !== undefined && typeof tx.TransferRate !== 'number') {
+    throw new ValidationError('AccountSet: invalid TransferRate')
+  }
+
+  if (tx.TickSize !== undefined) {
+    if (typeof tx.TickSize !== 'number') {
+      throw new ValidationError('AccountSet: invalid TickSize')
+    }
+    if (
+      tx.TickSize !== 0 &&
+      (tx.TickSize < MIN_TICK_SIZE || tx.TickSize > MAX_TICK_SIZE)
+    ) {
+      throw new ValidationError('AccountSet: invalid TickSize')
+    }
+  }
+}

package/src/models/transactions/checkCancel.ts

@@ -0,0 +1,34 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ * Cancels an unredeemed Check, removing it from the ledger without sending any
+ * money. The source or the destination of the check can cancel a Check at any
+ * time using this transaction type. If the Check has expired, any address can
+ * cancel it.
+ *
+ * @category Transaction Models
+ */
+export interface CheckCancel extends BaseTransaction {
+  TransactionType: 'CheckCancel'
+  /**
+   * The ID of the Check ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  CheckID: string
+}
+
+/**
+ * Verify the form and type of an CheckCancel at runtime.
+ *
+ * @param tx - An CheckCancel Transaction.
+ * @throws When the CheckCancel is Malformed.
+ */
+export function validateCheckCancel(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.CheckID !== undefined && typeof tx.CheckID !== 'string') {
+    throw new ValidationError('CheckCancel: invalid CheckID')
+  }
+}

package/src/models/transactions/checkCash.ts

@@ -0,0 +1,72 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+
+import { BaseTransaction, validateBaseTransaction, isAmount } from './common'
+
+/**
+ * Attempts to redeem a Check object in the ledger to receive up to the amount
+ * authorized by the corresponding CheckCreate transaction. Only the Destination
+ * address of a Check can cash it with a CheckCash transaction.
+ *
+ * @category Transaction Models
+ */
+export interface CheckCash extends BaseTransaction {
+  TransactionType: 'CheckCash'
+  /**
+   * The ID of the Check ledger object to cash as a 64-character hexadecimal
+   * string.
+   */
+  CheckID: string
+  /**
+   * Redeem the Check for exactly this amount, if possible. The currency must
+   * match that of the SendMax of the corresponding CheckCreate transaction. You.
+   * must provide either this field or DeliverMin.
+   */
+  Amount?: Amount
+  /**
+   * Redeem the Check for at least this amount and for as much as possible. The
+   * currency must match that of the SendMax of the corresponding CheckCreate.
+   * transaction. You must provide either this field or Amount.
+   */
+  DeliverMin?: Amount
+}
+
+/**
+ * Verify the form and type of an CheckCash at runtime.
+ *
+ * @param tx - An CheckCash Transaction.
+ * @throws When the CheckCash is Malformed.
+ */
+export function validateCheckCash(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Amount == null && tx.DeliverMin == null) {
+    throw new ValidationError(
+      'CheckCash: must have either Amount or DeliverMin',
+    )
+  }
+
+  if (tx.Amount != null && tx.DeliverMin != null) {
+    throw new ValidationError(
+      'CheckCash: cannot have both Amount and DeliverMin',
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Necessary check
+  if (tx.Amount != null && tx.Amount !== undefined && !isAmount(tx.Amount)) {
+    throw new ValidationError('CheckCash: invalid Amount')
+  }
+
+  if (
+    tx.DeliverMin != null &&
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Necessary check
+    tx.DeliverMin !== undefined &&
+    !isAmount(tx.DeliverMin)
+  ) {
+    throw new ValidationError('CheckCash: invalid DeliverMin')
+  }
+
+  if (tx.CheckID !== undefined && typeof tx.CheckID !== 'string') {
+    throw new ValidationError('CheckCash: invalid CheckID')
+  }
+}

package/src/models/transactions/checkCreate.ts

@@ -0,0 +1,82 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  isIssuedCurrency,
+  isAccount,
+  validateRequiredField,
+  validateOptionalField,
+  isNumber,
+  Account,
+} from './common'
+
+/**
+ * Create a Check object in the ledger, which is a deferred payment that can be
+ * cashed by its intended destination. The sender of this transaction is the
+ * sender of the Check.
+ *
+ * @category Transaction Models
+ */
+export interface CheckCreate extends BaseTransaction {
+  TransactionType: 'CheckCreate'
+  /** The unique address of the account that can cash the Check. */
+  Destination: Account
+  /**
+   * Maximum amount of source currency the Check is allowed to debit the
+   * sender, including transfer fees on non-XRP currencies. The Check can only
+   * credit the destination with the same currency (from the same issuer, for
+   * non-XRP currencies). For non-XRP amounts, the nested field names MUST be.
+   * lower-case.
+   */
+  SendMax: Amount
+  /**
+   * Arbitrary tag that identifies the reason for the Check, or a hosted.
+   * recipient to pay.
+   */
+  DestinationTag?: number
+  /**
+   * Time after which the Check is no longer valid, in seconds since the Ripple.
+   * Epoch.
+   */
+  Expiration?: number
+  /**
+   * Arbitrary 256-bit hash representing a specific reason or identifier for.
+   * this Check.
+   */
+  InvoiceID?: string
+}
+
+/**
+ * Verify the form and type of an CheckCreate at runtime.
+ *
+ * @param tx - An CheckCreate Transaction.
+ * @throws When the CheckCreate is Malformed.
+ */
+export function validateCheckCreate(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.SendMax === undefined) {
+    throw new ValidationError('CheckCreate: missing field SendMax')
+  }
+
+  validateRequiredField(tx, 'Destination', isAccount)
+  validateOptionalField(tx, 'DestinationTag', isNumber)
+
+  if (
+    typeof tx.SendMax !== 'string' &&
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS
+    !isIssuedCurrency(tx.SendMax as Record<string, unknown>)
+  ) {
+    throw new ValidationError('CheckCreate: invalid SendMax')
+  }
+
+  if (tx.Expiration !== undefined && typeof tx.Expiration !== 'number') {
+    throw new ValidationError('CheckCreate: invalid Expiration')
+  }
+
+  if (tx.InvoiceID !== undefined && typeof tx.InvoiceID !== 'string') {
+    throw new ValidationError('CheckCreate: invalid InvoiceID')
+  }
+}

package/src/models/transactions/clawback.ts

@@ -0,0 +1,72 @@
+import { ValidationError } from '../../errors'
+import { IssuedCurrencyAmount, MPTAmount } from '../common'
+
+import {
+  BaseTransaction,
+  validateBaseTransaction,
+  isIssuedCurrency,
+  isMPTAmount,
+  isAccount,
+  validateOptionalField,
+} from './common'
+
+/**
+ * The Clawback transaction is used by the token issuer to claw back
+ * issued tokens from a holder.
+ */
+export interface Clawback extends BaseTransaction {
+  TransactionType: 'Clawback'
+  /**
+   * Indicates the AccountID that submitted this transaction. The account MUST
+   * be the issuer of the currency or MPT.
+   */
+  Account: string
+  /**
+   * The amount of currency or MPT to clawback, and it must be non-XRP. The nested field
+   * names MUST be lower-case. If the amount is IOU, the `issuer` field MUST be the holder's address,
+   * whom to be clawed back.
+   */
+  Amount: IssuedCurrencyAmount | MPTAmount
+  /**
+   * Indicates the AccountID that the issuer wants to clawback. This field is only valid for clawing back
+   * MPTs.
+   */
+  MPTokenHolder?: string
+}
+
+/**
+ * Verify the form and type of an Clawback at runtime.
+ *
+ * @param tx - An Clawback Transaction.
+ * @throws When the Clawback is Malformed.
+ */
+export function validateClawback(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+  validateOptionalField(tx, 'MPTokenHolder', isAccount)
+
+  if (tx.Amount == null) {
+    throw new ValidationError('Clawback: missing field Amount')
+  }
+
+  if (!isIssuedCurrency(tx.Amount) && !isMPTAmount(tx.Amount)) {
+    throw new ValidationError('Clawback: invalid Amount')
+  }
+
+  if (isIssuedCurrency(tx.Amount) && tx.Account === tx.Amount.issuer) {
+    throw new ValidationError('Clawback: invalid holder Account')
+  }
+
+  if (isMPTAmount(tx.Amount) && tx.Account === tx.MPTokenHolder) {
+    throw new ValidationError('Clawback: invalid holder Account')
+  }
+
+  if (isIssuedCurrency(tx.Amount) && tx.MPTokenHolder) {
+    throw new ValidationError(
+      'Clawback: cannot have MPTokenHolder for currency',
+    )
+  }
+
+  if (isMPTAmount(tx.Amount) && !tx.MPTokenHolder) {
+    throw new ValidationError('Clawback: missing MPTokenHolder')
+  }
+}