xrpl 1.0.0-mpt-beta

package/src/sugar/submit.ts

@@ -0,0 +1,293 @@
+import { decode, encode } from 'ripple-binary-codec'
+
+import type {
+  Client,
+  SubmitRequest,
+  SubmitResponse,
+  SubmittableTransaction,
+  Transaction,
+  Wallet,
+} from '..'
+import { ValidationError, XrplError } from '../errors'
+import { Signer } from '../models/common'
+import { TxRequest, TxResponse } from '../models/methods'
+import { BaseTransaction } from '../models/transactions/common'
+
+/** Approximate time for a ledger to close, in milliseconds */
+const LEDGER_CLOSE_TIME = 1000
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+// Helper functions
+
+/**
+ * Submits a request to the client with a signed transaction.
+ *
+ * @param client - The client to submit the request to.
+ * @param signedTransaction - The signed transaction to submit. It can be either a Transaction object or a
+ * string (encode from ripple-binary-codec) representation of the transaction.
+ * @param [failHard=false] - Optional. Determines whether the submission should fail hard (true) or not (false). Default is false.
+ * @returns A promise that resolves with the response from the client.
+ * @throws {ValidationError} If the signed transaction is not valid (not signed).
+ *
+ * @example
+ * import { Client } from "xrpl"
+ * const client = new Client("wss://s.altnet.rippletest.net:51233");
+ * await client.connect();
+ * const signedTransaction = createSignedTransaction();
+ * // Example 1: Submitting a Transaction object
+ * const response1 = await submitRequest(client, signedTransaction);
+ *
+ * // Example 2: Submitting a string representation of the transaction
+ * const signedTransactionString = encode(signedTransaction);
+ * const response2 = await submitRequest(client, signedTransactionString, true);
+ */
+export async function submitRequest(
+  client: Client,
+  signedTransaction: SubmittableTransaction | string,
+  failHard = false,
+): Promise<SubmitResponse> {
+  if (!isSigned(signedTransaction)) {
+    throw new ValidationError('Transaction must be signed')
+  }
+
+  const signedTxEncoded =
+    typeof signedTransaction === 'string'
+      ? signedTransaction
+      : encode(signedTransaction)
+  const request: SubmitRequest = {
+    command: 'submit',
+    tx_blob: signedTxEncoded,
+    fail_hard: isAccountDelete(signedTransaction) || failHard,
+  }
+  return client.request(request)
+}
+
+/**
+ * Waits for the final outcome of a transaction by polling the ledger until the result can be considered final,
+ * meaning it has either been included in a validated ledger, or the transaction's lastLedgerSequence has been
+ * surpassed by the latest ledger sequence (meaning it will never be included in a validated ledger).
+ *
+ * @template T - The type of the transaction. Defaults to `Transaction`.
+ * @param client - The client to use for requesting transaction information.
+ * @param txHash - The hash of the transaction to wait for.
+ * @param lastLedger - The last ledger sequence of the transaction.
+ * @param submissionResult - The preliminary result of the transaction.
+ * @returns A promise that resolves with the final transaction response.
+ *
+ * @throws {XrplError} If the latest ledger sequence surpasses the transaction's lastLedgerSequence.
+ *
+ * @example
+ * import { hashes, Client } from "xrpl"
+ * const client = new Client("wss://s.altnet.rippletest.net:51233")
+ * await client.connect()
+ *
+ * const transaction = createTransaction() // your transaction function
+ *
+ * const signedTx = await getSignedTx(this, transaction)
+ *
+ * const lastLedger = getLastLedgerSequence(signedTx)
+ *
+ * if (lastLedger == null) {
+ *   throw new ValidationError(
+ *     'Transaction must contain a LastLedgerSequence value for reliable submission.',
+ *   )
+ * }
+ *
+ * const response = await submitRequest(this, signedTx, opts?.failHard)
+ *
+ * const txHash = hashes.hashSignedTx(signedTx)
+ * return waitForFinalTransactionOutcome(
+ *   this,
+ *   txHash,
+ *   lastLedger,
+ *   response.result.engine_result,
+ * )
+ */
+// eslint-disable-next-line max-params, max-lines-per-function -- this function needs to display and do with more information.
+export async function waitForFinalTransactionOutcome<
+  T extends BaseTransaction = SubmittableTransaction,
+>(
+  client: Client,
+  txHash: string,
+  lastLedger: number,
+  submissionResult: string,
+): Promise<TxResponse<T>> {
+  await sleep(LEDGER_CLOSE_TIME)
+
+  const latestLedger = await client.getLedgerIndex()
+
+  if (lastLedger < latestLedger) {
+    throw new XrplError(
+      `The latest ledger sequence ${latestLedger} is greater than the transaction's LastLedgerSequence (${lastLedger}).\n` +
+        `Preliminary result: ${submissionResult}`,
+    )
+  }
+
+  const txResponse = await client
+    .request<TxRequest, TxResponse<T>>({
+      command: 'tx',
+      transaction: txHash,
+    })
+    .catch(async (error) => {
+      // error is of an unknown type and hence we assert type to extract the value we need.
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,@typescript-eslint/no-unsafe-member-access -- ^
+      const message = error?.data?.error as string
+      if (message === 'txnNotFound') {
+        return waitForFinalTransactionOutcome<T>(
+          client,
+          txHash,
+          lastLedger,
+          submissionResult,
+        )
+      }
+      throw new Error(
+        `${message} \n Preliminary result: ${submissionResult}.\nFull error details: ${String(
+          error,
+        )}`,
+      )
+    })
+
+  if (txResponse.result.validated) {
+    return txResponse
+  }
+
+  return waitForFinalTransactionOutcome<T>(
+    client,
+    txHash,
+    lastLedger,
+    submissionResult,
+  )
+}
+
+// checks if the transaction has been signed
+function isSigned(transaction: SubmittableTransaction | string): boolean {
+  const tx = typeof transaction === 'string' ? decode(transaction) : transaction
+  if (typeof tx === 'string') {
+    return false
+  }
+  if (tx.Signers != null) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that tx.Signers is an array of Signers
+    const signers = tx.Signers as Signer[]
+    for (const signer of signers) {
+      // eslint-disable-next-line max-depth -- necessary for checking if signer is signed
+      if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- necessary check
+        signer.Signer.SigningPubKey == null ||
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- necessary check
+        signer.Signer.TxnSignature == null
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+  return tx.SigningPubKey != null && tx.TxnSignature != null
+}
+
+/**
+ * Updates a transaction with `autofill` then signs it if it is unsigned.
+ *
+ * @param client - The client from which to retrieve the signed transaction.
+ * @param transaction - The transaction to retrieve. It can be either a Transaction object or
+ * a string (encode from ripple-binary-codec) representation of the transaction.
+ * @param [options={}] - Optional. Additional options for retrieving the signed transaction.
+ * @param [options.autofill=true] - Optional. Determines whether the transaction should be autofilled (true)
+ * or not (false). Default is true.
+ * @param [options.wallet] - Optional. A wallet to sign the transaction. It must be provided when submitting
+ * an unsigned transaction. Default is undefined.
+ * @returns A promise that resolves with the signed transaction.
+ *
+ * @throws {ValidationError} If the transaction is not signed and no wallet is provided.
+ *
+ * @example
+ * import { Client } from "xrpl"
+ * import { encode } from "ripple-binary-codec"
+ *
+ * const client = new Client("wss://s.altnet.rippletest.net:51233");
+ * await client.connect():
+ * const transaction = createTransaction(); // createTransaction is your function to create a transaction
+ * const options = {
+ *   autofill: true,
+ *   wallet: myWallet,
+ * };
+ *
+ * // Example 1: Retrieving a signed Transaction object
+ * const signedTx1 = await getSignedTx(client, transaction, options);
+ *
+ * // Example 2: Retrieving a string representation of the signed transaction
+ * const signedTxString = await getSignedTx(client, encode(transaction), options);
+ */
+export async function getSignedTx(
+  client: Client,
+  transaction: SubmittableTransaction | string,
+  {
+    autofill = true,
+    wallet,
+  }: {
+    // If true, autofill a transaction.
+    autofill?: boolean
+    // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
+    wallet?: Wallet
+  } = {},
+): Promise<SubmittableTransaction | string> {
+  if (isSigned(transaction)) {
+    return transaction
+  }
+
+  if (!wallet) {
+    throw new ValidationError(
+      'Wallet must be provided when submitting an unsigned transaction',
+    )
+  }
+
+  let tx =
+    typeof transaction === 'string'
+      ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts JsonObject to correct Transaction type
+        (decode(transaction) as unknown as SubmittableTransaction)
+      : transaction
+
+  if (autofill) {
+    tx = await client.autofill(tx)
+  }
+
+  return wallet.sign(tx).tx_blob
+}
+
+// checks if there is a LastLedgerSequence as a part of the transaction
+/**
+ * Retrieves the last ledger sequence from a transaction.
+ *
+ * @param transaction - The transaction to retrieve the last ledger sequence from. It can be either a Transaction object or
+ * a string (encode from ripple-binary-codec) representation of the transaction.
+ * @returns The last ledger sequence of the transaction, or null if not available.
+ *
+ * @example
+ * const transaction = createTransaction(); // your function to create a transaction
+ *
+ * // Example 1: Retrieving the last ledger sequence from a Transaction object
+ * const lastLedgerSequence1 = getLastLedgerSequence(transaction);
+ * console.log(lastLedgerSequence1); // Output: 12345
+ *
+ * // Example 2: Retrieving the last ledger sequence from a string representation of the transaction
+ * const transactionString = encode(transaction);
+ * const lastLedgerSequence2 = getLastLedgerSequence(transactionString);
+ * console.log(lastLedgerSequence2); // Output: 67890
+ */
+export function getLastLedgerSequence(
+  transaction: Transaction | string,
+): number | null {
+  const tx = typeof transaction === 'string' ? decode(transaction) : transaction
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts LastLedgSeq to number if present.
+  return tx.LastLedgerSequence as number | null
+}
+
+// checks if the transaction is an AccountDelete transaction
+function isAccountDelete(transaction: Transaction | string): boolean {
+  const tx = typeof transaction === 'string' ? decode(transaction) : transaction
+  return tx.TransactionType === 'AccountDelete'
+}

package/src/sugar/utils.ts

@@ -0,0 +1,29 @@
+import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'
+
+/**
+ * If an address is an X-Address, converts it to a classic address.
+ *
+ * @param account - A classic address or X-address.
+ * @returns The account's classic address.
+ * @throws Error if the X-Address has an associated tag.
+ */
+export function ensureClassicAddress(account: string): string {
+  if (isValidXAddress(account)) {
+    const { classicAddress, tag } = xAddressToClassicAddress(account)
+
+    /*
+     * Except for special cases, X-addresses used for requests
+     * must not have an embedded tag. In other words,
+     * `tag` should be `false`.
+     */
+    if (tag !== false) {
+      throw new Error(
+        'This command does not support the use of a tag. Use an address without a tag.',
+      )
+    }
+
+    // For rippled requests that use an account, always use a classic address.
+    return classicAddress
+  }
+  return account
+}

package/src/utils/collections.ts

@@ -0,0 +1,57 @@
+type ValueOf<T> = T[keyof T]
+
+/**
+ * Creates an object composed of keys generated from the results of running each element of collection thru iteratee.
+ * The order of grouped values is determined by the order they occur in collection.
+ * The corresponding value of each key is an array of elements responsible for generating the key.
+ *
+ * Similar to lodash's groupBy
+ *
+ * @param array - array to iterate over
+ * @param iteratee - function that returns key of the group to place the item
+ *
+ * @returns a map of arrays
+ */
+export function groupBy<T>(
+  array: T[],
+  iteratee: (value: T, index: number, array: T[]) => string | number,
+): Record<string | number, T[]> {
+  // eslint-disable-next-line max-params -- need all the params for the fallback
+  function predicate(
+    acc: Record<string | number, T[]>,
+    value: T,
+    index: number,
+    arrayReference: T[],
+  ): Record<string | number, T[]> {
+    const key = iteratee(value, index, arrayReference) || 0
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Find existing group or create a new one
+    const group = acc[key] || []
+    group.push(value)
+    acc[key] = group
+    return acc
+  }
+
+  return array.reduce(predicate, {})
+}
+
+/**
+ * Creates an object composed of the own and inherited enumerable string keyed properties of object that
+ * predicate doesn't return truthy for.
+ *
+ * @param obj - Object to have properties removed.
+ * @param predicate - function that returns whether the property should be removed from the obj.
+ *
+ * @returns object
+ */
+export function omitBy<T extends object>(
+  obj: T,
+  predicate: (objElement: ValueOf<T>, k: string | number | symbol) => boolean,
+): Partial<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know the keys are properties of T
+  const keys: Array<keyof T> = Object.keys(obj) as Array<keyof T>
+  const keysToKeep = keys.filter((kb) => !predicate(obj[kb], kb))
+  return keysToKeep.reduce((acc: Partial<T>, key: keyof T) => {
+    acc[key] = obj[key]
+    return acc
+  }, {})
+}

package/src/utils/derive.ts

@@ -0,0 +1,23 @@
+import { classicAddressToXAddress } from 'ripple-address-codec'
+import { deriveKeypair, deriveAddress } from 'ripple-keypairs'
+
+/**
+ * Derive an X-Address from a public key and a destination tag.
+ *
+ * @param options - Public key and destination tag to encode as an X-Address.
+ * @param options.publicKey - The public key corresponding to an address.
+ * @param options.tag - A destination tag to encode into an X-address. False indicates no destination tag.
+ * @param options.test - Whether this address is for use in Testnet.
+ * @returns X-Address.
+ * @category Utilities
+ */
+function deriveXAddress(options: {
+  publicKey: string
+  tag: number | false
+  test: boolean
+}): string {
+  const classicAddress = deriveAddress(options.publicKey)
+  return classicAddressToXAddress(classicAddress, options.tag, options.test)
+}
+
+export { deriveKeypair, deriveAddress, deriveXAddress }

package/src/utils/getBalanceChanges.ts

@@ -0,0 +1,185 @@
+import BigNumber from 'bignumber.js'
+
+import {
+  Amount,
+  Balance,
+  IssuedCurrencyAmount,
+  TransactionMetadata,
+  Node,
+} from '../models'
+
+import { groupBy } from './collections'
+import { dropsToXrp } from './xrpConversion'
+
+interface BalanceChange {
+  account: string
+  balance: Balance
+}
+interface Fields {
+  Account?: string
+  Balance?: Amount
+  LowLimit?: IssuedCurrencyAmount
+  HighLimit?: IssuedCurrencyAmount
+  // eslint-disable-next-line @typescript-eslint/member-ordering -- okay here, just some of the fields are typed to make it easier
+  [field: string]: unknown
+}
+
+interface NormalizedNode {
+  // 'CreatedNode' | 'ModifiedNode' | 'DeletedNode'
+  NodeType: string
+  LedgerEntryType: string
+  LedgerIndex: string
+  NewFields?: Fields
+  FinalFields?: Fields
+  PreviousFields?: Fields
+  PreviousTxnID?: string
+  PreviousTxnLgrSeq?: number
+}
+
+function normalizeNode(affectedNode: Node): NormalizedNode {
+  const diffType = Object.keys(affectedNode)[0]
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- not quite right, but close enough
+  const node = affectedNode[diffType] as NormalizedNode
+  return {
+    ...node,
+    NodeType: diffType,
+    LedgerEntryType: node.LedgerEntryType,
+    LedgerIndex: node.LedgerIndex,
+    NewFields: node.NewFields,
+    FinalFields: node.FinalFields,
+    PreviousFields: node.PreviousFields,
+  }
+}
+
+function normalizeNodes(metadata: TransactionMetadata): NormalizedNode[] {
+  if (metadata.AffectedNodes.length === 0) {
+    return []
+  }
+  return metadata.AffectedNodes.map(normalizeNode)
+}
+
+function groupByAccount(balanceChanges: BalanceChange[]): Array<{
+  account: string
+  balances: Balance[]
+}> {
+  const grouped = groupBy(balanceChanges, (node) => node.account)
+  return Object.entries(grouped).map(([account, items]) => {
+    return { account, balances: items.map((item) => item.balance) }
+  })
+}
+
+function getValue(balance: Amount): BigNumber {
+  if (typeof balance === 'string') {
+    return new BigNumber(balance)
+  }
+  return new BigNumber(balance.value)
+}
+
+function computeBalanceChange(node: NormalizedNode): BigNumber | null {
+  let value: BigNumber | null = null
+  if (node.NewFields?.Balance) {
+    value = getValue(node.NewFields.Balance)
+  } else if (node.PreviousFields?.Balance && node.FinalFields?.Balance) {
+    value = getValue(node.FinalFields.Balance).minus(
+      getValue(node.PreviousFields.Balance),
+    )
+  }
+  if (value === null || value.isZero()) {
+    return null
+  }
+  return value
+}
+
+function getXRPQuantity(
+  node: NormalizedNode,
+): { account: string; balance: Balance } | null {
+  const value = computeBalanceChange(node)
+
+  if (value === null) {
+    return null
+  }
+
+  return {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- okay here
+    account: (node.FinalFields?.Account ?? node.NewFields?.Account) as string,
+    balance: {
+      currency: 'XRP',
+      value: dropsToXrp(value).toString(),
+    },
+  }
+}
+
+function flipTrustlinePerspective(balanceChange: BalanceChange): BalanceChange {
+  const negatedBalance = new BigNumber(balanceChange.balance.value).negated()
+  return {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know this is true
+    account: balanceChange.balance.issuer as string,
+    balance: {
+      issuer: balanceChange.account,
+      currency: balanceChange.balance.currency,
+      value: negatedBalance.toString(),
+    },
+  }
+}
+
+function getTrustlineQuantity(node: NormalizedNode): BalanceChange[] | null {
+  const value = computeBalanceChange(node)
+
+  if (value === null) {
+    return null
+  }
+
+  /*
+   * A trustline can be created with a non-zero starting balance.
+   * If an offer is placed to acquire an asset with no existing trustline,
+   * the trustline can be created when the offer is taken.
+   */
+  const fields = node.NewFields == null ? node.FinalFields : node.NewFields
+
+  // the balance is always from low node's perspective
+  const result = {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that this is true
+    account: fields?.LowLimit?.issuer as string,
+    balance: {
+      issuer: fields?.HighLimit?.issuer,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that this is true
+      currency: (fields?.Balance as IssuedCurrencyAmount).currency,
+      value: value.toString(),
+    },
+  }
+  return [result, flipTrustlinePerspective(result)]
+}
+
+/**
+ * Computes the complete list of every balance that changed in the ledger
+ * as a result of the given transaction.
+ *
+ * @param metadata - Transaction metadata.
+ * @returns Parsed balance changes.
+ * @category Utilities
+ */
+export default function getBalanceChanges(
+  metadata: TransactionMetadata,
+): Array<{
+  account: string
+  balances: Balance[]
+}> {
+  const quantities = normalizeNodes(metadata).map((node) => {
+    if (node.LedgerEntryType === 'AccountRoot') {
+      const xrpQuantity = getXRPQuantity(node)
+      if (xrpQuantity == null) {
+        return []
+      }
+      return [xrpQuantity]
+    }
+    if (node.LedgerEntryType === 'RippleState') {
+      const trustlineQuantity = getTrustlineQuantity(node)
+      if (trustlineQuantity == null) {
+        return []
+      }
+      return trustlineQuantity
+    }
+    return []
+  })
+  return groupByAccount(quantities.flat())
+}

package/src/utils/getNFTokenID.ts

@@ -0,0 +1,99 @@
+import { decode } from 'ripple-binary-codec'
+
+import { NFToken } from '../models/ledger/NFTokenPage'
+import {
+  CreatedNode,
+  isCreatedNode,
+  isModifiedNode,
+  ModifiedNode,
+  TransactionMetadata,
+} from '../models/transactions/metadata'
+
+/**
+ * Ensures that the metadata is in a deserialized format to parse.
+ *
+ * @param meta - the metadata from a `tx` method call. Can be in json format or binary format.
+ * @returns the metadata in a deserialized format.
+ */
+function ensureDecodedMeta(
+  meta: TransactionMetadata | string,
+): TransactionMetadata {
+  if (typeof meta === 'string') {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Meta is either metadata or serialized metadata.
+    return decode(meta) as unknown as TransactionMetadata
+  }
+  return meta
+}
+
+/**
+ * Gets the NFTokenID for an NFT recently minted with NFTokenMint.
+ *
+ * @param meta - Metadata from the response to submitting and waiting for an NFTokenMint transaction or from a `tx` method call.
+ * @returns The NFTokenID for the minted NFT.
+ * @throws if meta is not TransactionMetadata.
+ */
+// eslint-disable-next-line max-lines-per-function -- This function has a lot of documentation
+export default function getNFTokenID(
+  meta: TransactionMetadata | string | undefined,
+): string | undefined {
+  if (typeof meta !== 'string' && meta?.AffectedNodes === undefined) {
+    throw new TypeError(`Unable to parse the parameter given to getNFTokenID.
+      'meta' must be the metadata from an NFTokenMint transaction. Received ${JSON.stringify(
+        meta,
+      )} instead.`)
+  }
+
+  const decodedMeta = ensureDecodedMeta(meta)
+
+  /*
+   * When a mint results in splitting an existing page,
+   * it results in a created page and a modified node. Sometimes,
+   * the created node needs to be linked to a third page, resulting
+   * in modifying that third page's PreviousPageMin or NextPageMin
+   * field changing, but no NFTs within that page changing. In this
+   * case, there will be no previous NFTs and we need to skip.
+   * However, there will always be NFTs listed in the final fields,
+   * as rippled outputs all fields in final fields even if they were
+   * not changed. Thus why we add the additional condition to check
+   * if the PreviousFields contains NFTokens
+   */
+  const affectedNodes = decodedMeta.AffectedNodes.filter((node) => {
+    if (isCreatedNode(node)) {
+      return node.CreatedNode.LedgerEntryType === 'NFTokenPage'
+    }
+    if (isModifiedNode(node)) {
+      return (
+        node.ModifiedNode.LedgerEntryType === 'NFTokenPage' &&
+        Boolean(node.ModifiedNode.PreviousFields?.NFTokens)
+      )
+    }
+    return false
+  })
+  /* eslint-disable @typescript-eslint/consistent-type-assertions -- Necessary for parsing metadata */
+  const previousTokenIDSet = new Set(
+    affectedNodes
+      .flatMap((node) => {
+        const nftokens = isModifiedNode(node)
+          ? (node.ModifiedNode.PreviousFields?.NFTokens as NFToken[])
+          : []
+        return nftokens.map((token) => token.NFToken.NFTokenID)
+      })
+      .filter((id) => Boolean(id)),
+  )
+
+  /* eslint-disable @typescript-eslint/no-unnecessary-condition -- Cleaner to read */
+  const finalTokenIDs = affectedNodes
+    .flatMap((node) =>
+      (
+        (((node as ModifiedNode).ModifiedNode?.FinalFields?.NFTokens ??
+          (node as CreatedNode).CreatedNode?.NewFields
+            ?.NFTokens) as NFToken[]) ?? []
+      ).map((token) => token.NFToken.NFTokenID),
+    )
+    .filter((nftokenID) => Boolean(nftokenID))
+  /* eslint-enable @typescript-eslint/consistent-type-assertions -- Necessary for parsing metadata */
+  /* eslint-enable @typescript-eslint/no-unnecessary-condition -- Cleaner to read */
+  const nftokenID = finalTokenIDs.find((id) => !previousTokenIDSet.has(id))
+
+  return nftokenID
+}