xrpl 2.12.0 → 3.0.0-beta.0

package/src/sugar/balances.ts

@@ -1,123 +1,15 @@
-import flatMap from 'lodash/flatMap'
+import { AccountLinesTrustline, Balance } from '../models'
 
-import type { Balance, Client } from '..'
-import {
-  AccountLinesRequest,
-  AccountLinesTrustline,
-  LedgerIndex,
-  AccountInfoRequest,
-} from '../models'
-import { dropsToXrp } from '../utils'
-
-function formatBalances(trustlines: AccountLinesTrustline[]): Balance[] {
+/**
+ * Formats an array of trustlines into an array of balances.
+ *
+ * @param trustlines - The array of trustlines to format.
+ * @returns An array of balances, each containing the value, currency, and issuer.
+ */
+export function formatBalances(trustlines: AccountLinesTrustline[]): Balance[] {
   return trustlines.map((trustline) => ({
     value: trustline.balance,
     currency: trustline.currency,
     issuer: trustline.account,
   }))
 }
-
-/**
- * Get the XRP balance for an account.
- *
- * @example
- * ```ts
- * const client = new Client(wss://s.altnet.rippletest.net:51233)
- * const balance = await client.getXrpBalance('rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn')
- * console.log(balance)
- * /// '200'
- * ```
- *
- * @param this - Client.
- * @param address - Address of the account to retrieve XRP balance.
- * @param options - Options to include for getting the XRP balance.
- * @param options.ledger_index - Retrieve the account balances at a given
- * ledger_index.
- * @param options.ledger_hash - Retrieve the account balances at the ledger with
- * a given ledger_hash.
- * @returns The XRP balance of the account (as a string).
- */
-async function getXrpBalance(
-  this: Client,
-  address: string,
-  options: {
-    ledger_hash?: string
-    ledger_index?: LedgerIndex
-  } = {},
-): Promise<string> {
-  const xrpRequest: AccountInfoRequest = {
-    command: 'account_info',
-    account: address,
-    ledger_index: options.ledger_index ?? 'validated',
-    ledger_hash: options.ledger_hash,
-  }
-  const response = await this.request(xrpRequest)
-  return dropsToXrp(response.result.account_data.Balance)
-}
-
-/**
- * Get XRP/non-XRP balances for an account.
- *
- * @param this - Client.
- * @param address - Address of the account to retrieve balances for.
- * @param options - Allows the client to specify a ledger_hash, ledger_index,
- * filter by peer, and/or limit number of balances.
- * @param options.ledger_index - Retrieve the account balances at a given
- * ledger_index.
- * @param options.ledger_hash - Retrieve the account balances at the ledger with
- * a given ledger_hash.
- * @param options.peer - Filter balances by peer.
- * @param options.limit - Limit number of balances to return.
- * @returns An array of XRP/non-XRP balances for the given account.
- */
-// eslint-disable-next-line max-lines-per-function -- Longer definition is required for end users to see the definition.
-async function getBalances(
-  this: Client,
-  address: string,
-  options: {
-    ledger_hash?: string
-    ledger_index?: LedgerIndex
-    peer?: string
-    limit?: number
-  } = {},
-): Promise<
-  Array<{ value: string; currency: string; issuer?: string | undefined }>
-> {
-  const balances: Balance[] = []
-
-  // get XRP balance
-  let xrpPromise: Promise<string> = Promise.resolve('')
-  if (!options.peer) {
-    xrpPromise = this.getXrpBalance(address, {
-      ledger_hash: options.ledger_hash,
-      ledger_index: options.ledger_index,
-    })
-  }
-
-  // get non-XRP balances
-  const linesRequest: AccountLinesRequest = {
-    command: 'account_lines',
-    account: address,
-    ledger_index: options.ledger_index ?? 'validated',
-    ledger_hash: options.ledger_hash,
-    peer: options.peer,
-    limit: options.limit,
-  }
-  const linesPromise = this.requestAll(linesRequest)
-
-  // combine results
-  await Promise.all([xrpPromise, linesPromise]).then(
-    ([xrpBalance, linesResponses]) => {
-      const accountLinesBalance = flatMap(linesResponses, (response) =>
-        formatBalances(response.result.lines),
-      )
-      if (xrpBalance !== '') {
-        balances.push({ currency: 'XRP', value: xrpBalance })
-      }
-      balances.push(...accountLinesBalance)
-    },
-  )
-  return balances.slice(0, options.limit)
-}
-
-export { getXrpBalance, getBalances }

package/src/sugar/getOrderbook.ts

@@ -1,6 +1,4 @@
-/* eslint-disable max-lines-per-function -- Needs to process orderbooks. */
 import BigNumber from 'bignumber.js'
-import flatMap from 'lodash/flatMap'
 
 import type { Client } from '../client'
 import { ValidationError } from '../errors'
@@ -31,43 +29,40 @@ const getOrderbookOptionsSet = new Set([
 ])
 
 /**
- * Fetch orderbook (buy/sell orders) between two currency pairs. This checks both sides of the orderbook
- * by making two `order_book` requests (with the second reversing takerPays and takerGets). Returned offers are
- * not normalized in this function, so either currency could be takerGets or takerPays.
+ * Represents the options for retrieving the order book.
+ */
+export interface GetOrderBookOptions {
+  /**
+   * The limit on the number of offers to return.
+   */
+  limit?: number
+  /**
+   * The ledger index of the ledger to use.
+   */
+  ledger_index?: LedgerIndex
+  /**
+   * The ledger hash of the ledger to use.
+   */
+  ledger_hash?: string | null
+  /**
+   * The account that takes the offers.
+   */
+  taker?: string | null
+}
+
+/**
+ * Validates the options for retrieving the order book.
  *
- * @param this - Client.
- * @param currency1 - Specification of one currency involved. (With a currency code and optionally an issuer)
- * @param currency2 - Specification of a second currency involved. (With a currency code and optionally an issuer)
- * @param options - Options allowing the client to specify ledger_index,
- * ledger_hash, filter by taker, and/or limit number of orders.
- * @param options.ledger_index - Retrieve the orderbook at a given ledger_index.
- * @param options.ledger_hash - Retrieve the orderbook at the ledger with a
- * given ledger_hash.
- * @param options.taker - Filter orders by taker.
- * @param options.limit - The limit passed into each book_offers request.
- * Can return more than this due to two calls being made. Defaults to 20.
- * @returns An object containing buy and sell objects.
+ * @param options - The options to validate.
+ * @throws {ValidationError} If any validation errors occur.
  */
-// eslint-disable-next-line max-params, complexity -- Once bound to Client, getOrderbook only has 3 parameters.
-async function getOrderbook(
-  this: Client,
-  currency1: BookOfferCurrency,
-  currency2: BookOfferCurrency,
-  options: {
-    limit?: number
-    ledger_index?: LedgerIndex
-    ledger_hash?: string | null
-    taker?: string | null
-  } = {},
-): Promise<{
-  buy: BookOffer[]
-  sell: BookOffer[]
-}> {
-  Object.keys(options).forEach((key) => {
+// eslint-disable-next-line complexity -- Necessary for validation.
+export function validateOrderbookOptions(options: GetOrderBookOptions): void {
+  for (const key of Object.keys(options)) {
     if (!getOrderbookOptionsSet.has(key)) {
       throw new ValidationError(`Unexpected option: ${key}`, options)
     }
-  })
+  }
 
   if (options.limit && typeof options.limit !== 'number') {
     throw new ValidationError('limit must be a number', options.limit)
@@ -101,7 +96,30 @@ async function getOrderbook(
   if (options.taker !== undefined && typeof options.taker !== 'string') {
     throw new ValidationError('taker must be a string', options.taker)
   }
+}
 
+/**
+ * Creates a request object for retrieving book offers.
+ *
+ * @param currency1 - The first currency in the pair.
+ * @param currency2 - The second currency in the pair.
+ * @param options - Additional options for the request.
+ * @param [options.limit] - The maximum number of offers to retrieve.
+ * @param [options.ledger_index] - The ledger index to use for retrieval.
+ * @param [options.ledger_hash] - The ledger hash to use for retrieval.
+ * @param [options.taker] - The taker address for retrieval.
+ * @returns The created request object.
+ */
+export function createBookOffersRequest(
+  currency1: BookOfferCurrency,
+  currency2: BookOfferCurrency,
+  options: {
+    limit?: number
+    ledger_index?: LedgerIndex
+    ledger_hash?: string | null
+    taker?: string | null
+  },
+): BookOffersRequest {
   const request: BookOffersRequest = {
     command: 'book_offers',
     taker_pays: currency1,
@@ -111,25 +129,78 @@ async function getOrderbook(
     limit: options.limit ?? DEFAULT_LIMIT,
     taker: options.taker ? options.taker : undefined,
   }
-  // 2. Make Request
-  const directOfferResults = await this.requestAll(request)
-  request.taker_gets = currency1
-  request.taker_pays = currency2
-  const reverseOfferResults = await this.requestAll(request)
-  // 3. Return Formatted Response
-  const directOffers = flatMap(
-    directOfferResults,
-    (directOfferResult) => directOfferResult.result.offers,
-  )
-  const reverseOffers = flatMap(
-    reverseOfferResults,
-    (reverseOfferResult) => reverseOfferResult.result.offers,
-  )
-
-  const orders = [...directOffers, ...reverseOffers]
-  // separate out the buy and sell orders
+
+  return request
+}
+
+type BookOfferResult = BookOffer[]
+
+/**
+ * Retrieves all book offer results using the given request.
+ *
+ * @param client - The Ripple client.
+ * @param request - The request object.
+ * @returns The array of book offer results.
+ */
+export async function requestAllOffers(
+  client: Client,
+  request: BookOffersRequest,
+): Promise<BookOfferResult[]> {
+  const results = await client.requestAll(request)
+  return results.map((result) => result.result.offers)
+}
+
+/**
+ * Creates a reverse request object by swapping the taker pays and taker gets amounts.
+ *
+ * @param request - The original request object.
+ * @returns The reverse request object.
+ */
+export function reverseRequest(request: BookOffersRequest): BookOffersRequest {
+  return {
+    ...request,
+    taker_pays: request.taker_gets,
+    taker_gets: request.taker_pays,
+  }
+}
+
+/**
+ * Extracts the offers from the book offer results.
+ *
+ * @param offerResults - The array of book offer results.
+ * @returns The extracted offers.
+ */
+export function extractOffers(offerResults: BookOfferResult[]): BookOffer[] {
+  return offerResults.flatMap((offerResult) => offerResult)
+}
+
+/**
+ * Combines the direct and reverse offers into a single array.
+ *
+ * @param directOffers - The direct offers.
+ * @param reverseOffers - The reverse offers.
+ * @returns The combined array of offers.
+ */
+export function combineOrders(
+  directOffers: BookOffer[],
+  reverseOffers: BookOffer[],
+): BookOffer[] {
+  return [...directOffers, ...reverseOffers]
+}
+
+/**
+ * Separates the buy and sell orders from the given array of orders.
+ *
+ * @param orders - The array of orders.
+ * @returns The separated buy and sell orders.
+ */
+export function separateBuySellOrders(orders: BookOffer[]): {
+  buy: BookOffer[]
+  sell: BookOffer[]
+} {
   const buy: BookOffer[] = []
   const sell: BookOffer[] = []
+
   orders.forEach((order) => {
     // eslint-disable-next-line no-bitwise -- necessary for flags check
     if ((order.Flags & OfferFlags.lsfSell) === 0) {
@@ -138,15 +209,21 @@ async function getOrderbook(
       sell.push(order)
     }
   })
-  /*
-   * Sort the orders
-   * for both buys and sells, lowest quality is closest to mid-market
-   * we sort the orders so that earlier orders are closer to mid-market
-   */
-  return {
-    buy: sortOffers(buy).slice(0, options.limit),
-    sell: sortOffers(sell).slice(0, options.limit),
-  }
+
+  return { buy, sell }
 }
 
-export default getOrderbook
+/**
+ * Sorts and limits the given array of offers.
+ *
+ * @param offers - The array of offers to sort and limit.
+ * @param [limit] - The maximum number of offers to include.
+ * @returns The sorted and limited array of offers.
+ */
+export function sortAndLimitOffers(
+  offers: BookOffer[],
+  limit?: number,
+): BookOffer[] {
+  const sortedOffers = sortOffers(offers)
+  return sortedOffers.slice(0, limit)
+}

package/src/sugar/index.ts

@@ -1,11 +1,3 @@
-export { default as autofill } from './autofill'
-
-export { getBalances, getXrpBalance } from './balances'
-
-export { default as getLedgerIndex } from './getLedgerIndex'
-
-export { default as getOrderbook } from './getOrderbook'
-
 export * from './submit'
 
 export * from './utils'

package/src/sugar/submit.ts

@@ -6,7 +6,6 @@ import { Signer } from '../models/common'
 import { TxRequest, TxResponse } from '../models/methods'
 import { Transaction } from '../models/transactions'
 import { BaseTransaction } from '../models/transactions/common'
-import { hashes } from '../utils'
 
 /** Approximate time for a ledger to close, in milliseconds */
 const LEDGER_CLOSE_TIME = 1000
@@ -17,130 +16,31 @@ async function sleep(ms: number): Promise<void> {
   })
 }
 
-/**
- * Submits a signed/unsigned transaction.
- * Steps performed on a transaction:
- *    1. Autofill.
- *    2. Sign & Encode.
- *    3. Submit.
- *
- * @param this - A Client.
- * @param transaction - A transaction to autofill, sign & encode, and submit.
- * @param opts - (Optional) Options used to sign and submit a transaction.
- * @param opts.autofill - If true, autofill a transaction.
- * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
- * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
- * @returns A promise that contains SubmitResponse.
- * @throws RippledError if submit request fails.
- */
-async function submit(
-  this: Client,
-  transaction: Transaction | string,
-  opts?: {
-    // If true, autofill a transaction.
-    autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
-    // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
-    wallet?: Wallet
-  },
-): Promise<SubmitResponse> {
-  const signedTx = await getSignedTx(this, transaction, opts)
-  return submitRequest(this, signedTx, opts?.failHard)
-}
+// Helper functions
 
 /**
- * Asynchronously submits a transaction and verifies that it has been included in a
- * validated ledger (or has errored/will not be included for some reason).
- * See [Reliable Transaction Submission](https://xrpl.org/reliable-transaction-submission.html).
- *
- * @example
- *
- * ```ts
- * const { Client, Wallet } = require('xrpl')
- * const client = new Client('wss://s.altnet.rippletest.net:51233')
- *
- * async function submitTransaction() {
- *   const senderWallet = client.fundWallet()
- *   const recipientWallet = client.fundWallet()
- *
- *   const transaction = {
- *     TransactionType: 'Payment',
- *     Account: senderWallet.address,
- *     Destination: recipientWallet.address,
- *     Amount: '10'
- *   }
- *
- *   try {
- *     await client.submit(signedTransaction, { wallet: senderWallet })
- *     console.log(result)
- *   } catch (error) {
- *     console.error(`Failed to submit transaction: ${error}`)
- *   }
- * }
- *
- * submitTransaction()
- * ```
+ * Submits a request to the client with a signed transaction.
  *
- * In this example we submit a payment transaction between two newly created testnet accounts.
+ * @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).
  *
- * Under the hood, `submit` will call `client.autofill` by default, and because we've passed in a `Wallet` it
- * Will also sign the transaction for us before submitting the signed transaction binary blob to the ledger.
+ * @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);
  *
- * This is similar to `submitAndWait` which does all of the above, but also waits to see if the transaction has been validated.
- * @param this - A Client.
- * @param transaction - A transaction to autofill, sign & encode, and submit.
- * @param opts - (Optional) Options used to sign and submit a transaction.
- * @param opts.autofill - If true, autofill a transaction.
- * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
- * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
- * @throws Connection errors: If the `Client` object is unable to establish a connection to the specified WebSocket endpoint,
- * an error will be thrown.
- * @throws Transaction errors: If the submitted transaction is invalid or cannot be included in a validated ledger for any
- * reason, the promise returned by `submitAndWait()` will be rejected with an error. This could include issues with insufficient
- * balance, invalid transaction fields, or other issues specific to the transaction being submitted.
- * @throws Ledger errors: If the ledger being used to submit the transaction is undergoing maintenance or otherwise unavailable,
- * an error will be thrown.
- * @throws Timeout errors: If the transaction takes longer than the specified timeout period to be included in a validated
- * ledger, the promise returned by `submitAndWait()` will be rejected with an error.
- * @returns A promise that contains TxResponse, that will return when the transaction has been validated.
+ * // Example 2: Submitting a string representation of the transaction
+ * const signedTransactionString = encode(signedTransaction);
+ * const response2 = await submitRequest(client, signedTransactionString, true);
  */
-async function submitAndWait<T extends Transaction = Transaction>(
-  this: Client,
-  transaction: T | string,
-  opts?: {
-    // If true, autofill a transaction.
-    autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
-    // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
-    wallet?: Wallet
-  },
-): Promise<TxResponse<T>> {
-  const signedTx = await getSignedTx(this, transaction, opts)
-
-  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,
-  )
-}
-
-// Helper functions
-
-// Encodes and submits a signed transaction.
-async function submitRequest(
+export async function submitRequest(
   client: Client,
   signedTransaction: Transaction | string,
   failHard = false,
@@ -161,14 +61,49 @@ async function submitRequest(
   return client.request(request)
 }
 
-/*
- * The core logic of reliable submission.  This polls the ledger until the result of the
- * transaction 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).
+/**
+ * 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.
-async function waitForFinalTransactionOutcome<
+export async function waitForFinalTransactionOutcome<
   T extends BaseTransaction = Transaction,
 >(
   client: Client,
@@ -248,8 +183,40 @@ function isSigned(transaction: Transaction | string): boolean {
   return tx.SigningPubKey != null && tx.TxnSignature != null
 }
 
-// initializes a transaction for a submit request
-async function getSignedTx(
+/**
+ * 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: Transaction | string,
   {
@@ -258,8 +225,6 @@ async function getSignedTx(
   }: {
     // If true, autofill a transaction.
     autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
     // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
     wallet?: Wallet
   } = {},
@@ -288,7 +253,26 @@ async function getSignedTx(
 }
 
 // checks if there is a LastLedgerSequence as a part of the transaction
-function getLastLedgerSequence(
+/**
+ * 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
@@ -301,5 +285,3 @@ function isAccountDelete(transaction: Transaction | string): boolean {
   const tx = typeof transaction === 'string' ? decode(transaction) : transaction
   return tx.TransactionType === 'AccountDelete'
 }
-
-export { submit, submitAndWait }