xrpl 2.10.0 → 2.12.0-beta.0

package/src/sugar/index.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,305 @@
+import { decode, encode } from 'ripple-binary-codec'
+
+import type { Client, SubmitRequest, SubmitResponse, Wallet } from '..'
+import { ValidationError, XrplError } from '../errors'
+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
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+/**
+ * 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)
+}
+
+/**
+ * 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()
+ * ```
+ *
+ * In this example we submit a payment transaction between two newly created testnet accounts.
+ *
+ * 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.
+ *
+ * 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.
+ */
+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(
+  client: Client,
+  signedTransaction: Transaction | 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)
+}
+
+/*
+ * 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).
+ */
+// eslint-disable-next-line max-params, max-lines-per-function -- this function needs to display and do with more information.
+async function waitForFinalTransactionOutcome<
+  T extends BaseTransaction = Transaction,
+>(
+  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: Transaction | 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
+}
+
+// initializes a transaction for a submit request
+async function getSignedTx(
+  client: Client,
+  transaction: Transaction | string,
+  {
+    autofill = true,
+    wallet,
+  }: {
+    // 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<Transaction | 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 Transaction)
+      : 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
+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'
+}
+
+export { submit, submitAndWait }

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/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,186 @@
+import BigNumber from 'bignumber.js'
+import flatten from 'lodash/flatten'
+import groupBy from 'lodash/groupBy'
+
+import {
+  Amount,
+  Balance,
+  IssuedCurrencyAmount,
+  TransactionMetadata,
+  Node,
+} from '../models'
+
+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(flatten(quantities))
+}

package/src/utils/getNFTokenID.ts

@@ -0,0 +1,97 @@
+import flatMap from 'lodash/flatMap'
+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.
+ */
+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(
+    flatMap(affectedNodes, (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 = flatMap(affectedNodes, (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
+}

package/src/utils/hashes/HashPrefix.ts

@@ -0,0 +1,40 @@
+/**
+ * Prefix for hashing functions.
+ *
+ * These prefixes are inserted before the source material used to
+ * generate various hashes. This is done to put each hash in its own
+ * "space." This way, two different types of objects with the
+ * same binary data will produce different hashes.
+ *
+ * Each prefix is a 4-byte value with the last byte set to zero
+ * and the first three bytes formed from the ASCII equivalent of
+ * some arbitrary string. For example "TXN".
+ */
+
+enum HashPrefix {
+  // transaction plus signature to give transaction ID 'TXN'
+  TRANSACTION_ID = 0x54584e00,
+
+  // transaction plus metadata 'TND'
+  TRANSACTION_NODE = 0x534e4400,
+
+  // inner node in tree 'MIN'
+  INNER_NODE = 0x4d494e00,
+
+  // leaf node in tree 'MLN'
+  LEAF_NODE = 0x4d4c4e00,
+
+  // inner transaction to sign 'STX'
+  TRANSACTION_SIGN = 0x53545800,
+
+  // inner transaction to sign (TESTNET) 'stx'
+  TRANSACTION_SIGN_TESTNET = 0x73747800,
+
+  // inner transaction to multisign 'SMT'
+  TRANSACTION_MULTISIGN = 0x534d5400,
+
+  // ledger 'LWR'
+  LEDGER = 0x4c575200,
+}
+
+export default HashPrefix